Sorry your browser is not supported!

dim Btm_Timer(n) as integer
dim btm(n) as integer
dim t$(n) as string

`Init variables

global ter_limbdepth=3
global patch_mode=1

global freeobj=10000
global update_ter
global ter_limbcount
global ter_live as byte : ter_live=1

global stampx
global stampz

global size_x=512
global size_z=512
global brushmode=1
global cammode=1
global brushlayer=2
global curx#
global cury#
global curz#
global camx#
global camz#
global camy#

global terra_x=32
global terra_z=32

global elapsed#

global menuon=0
global lastmenu

type GUI_type

mode as byte
rem$ as string

endtype

type terrain_limbs
limbno as byte
live as byte
update as byte
endtype

dim GUI(128) as gui_type
dim ter(size_x,size_z) as float
dim map(1024,1024,7) as byte
dim menu$(256)
dim ter_limb(terra_x,terra_z) as terrain_limbs   `Entire ter_limb stuff would need changed to suit a non 512x512 terrain
Dim __ObjTaken(0) as boolean     ` Global array
gosub init

int ter_limbdepth = 3;
int patch_mode = 1;

int freeobj=10000;
int update_ter;
int ter_limbcount;
int ter_live as byte;
int ter_live=1;

int stampx;
int stampz;

int size_x=512;
int size_z=512;
int brushmode=1;
int cammode=1;
int brushlayer=2;
float curx;
float cury;
float curz;
float camx;
float camz;
float camy;

int terra_x=32;
int terra_z=32;

float elapsed;

int menuon=0;
int lastmenu;

struct GUI_type{

unsigned char mode;
string rem; //not sure if string is right

}

struct terrain_limbs{
unsigned char limbno; 
unsigned char live;
unsigned char update; 
}

#include <vector.h>

  MyArray->ar[iIndex];

MyArray->ar[iIndex] = (int)new JFC_AR();

Defining a 2 dimensional dynamic array in C++  

// array[n][m] Substitute into the following your values for m and n and var type

// creating the array
double** pp = new double* [n];
pp[0] = new double [n*m];
for (int i = 1; i < n; ++i)
pp[i] = pp[i-1] + m;

// using the array  
pp[n][m]

// deallocation
delete [] pp[0];
delete [] pp;

#include <vector>

template <typename Content>
class Array2D
{
private:
    typedef std::vector<Content> InnerVector;
    typedef std::vector<InnerVector> VectorArray;

public:
    typedef unsigned int IndexType;

    Array2D() : Width(0), Height(0)
    { }

    Array2D(int Width_, int Height_)
        : Width(Width_), Height(Height_), Array( Width_, InnerVector(Height_))
    { }

    typename VectorArray::reference operator[](IndexType Index)
    {
        return Array[Index];
    }

    typename VectorArray::const_reference operator[](IndexType Index) const
    {
        return Array[Index];
    }

    void SetWidth(IndexType NewWidth)
    {
        if (NewWidth > Width)
            Array.resize( NewWidth, InnerVector(Height) );
        else
            Array.resize( NewWidth );
        Width = NewWidth;
    }

    void SetHeight(IndexType NewHeight)
    {
        for (IndexType i = 0; i < Width; ++i)
        {
            Array[ i ].resize( NewHeight );
        }
        Height = NewHeight;
    }

    void SetSize(IndexType NewWidth, IndexType NewHeight)
    {
        SetHeight( NewHeight );
        SetWidth( NewWidth );
    }

    IndexType GetWidth() const { return Width; }
    IndexType GetHeight() const { return Height; }
private:
    IndexType Width;
    IndexType Height;
    VectorArray Array;
};

#include <iostream>

int main()
{
    Array2D<int> MyArray;
    MyArray = Array2D<int>(10, 10);
    int CellCount = 0;

    for (Array2D<int>::IndexType y = 0; y < MyArray.GetHeight(); ++y)
    {
        for (Array2D<int>::IndexType x = 0; x < MyArray.GetWidth(); ++x)
        {
            MyArray[x][y] = CellCount;
            ++CellCount;
        }
    }

    for (Array2D<int>::IndexType y = 0; y < MyArray.GetHeight(); ++y)
    {
        for (Array2D<int>::IndexType x = 0; x < MyArray.GetWidth(); ++x)
        {
            std::cout << MyArray[x][y] << ", ";
        }
        std::cout << '\n';
    }
    std::cout << '\n';

    MyArray.SetWidth( MyArray.GetWidth() + 2 );
    MyArray.SetHeight( MyArray.GetHeight() + 2 );
    for (Array2D<int>::IndexType y = 0; y < MyArray.GetHeight(); ++y)
    {
        for (Array2D<int>::IndexType x = 0; x < MyArray.GetWidth(); ++x)
        {
            std::cout << MyArray[x][y] << ", ";
        }
        std::cout << '\n';
    }
    std::cout << '\n';

    MyArray.SetSize( MyArray.GetWidth() - 2, MyArray.GetHeight() - 2 );
    for (Array2D<int>::IndexType y = 0; y < MyArray.GetHeight(); ++y)
    {
        for (Array2D<int>::IndexType x = 0; x < MyArray.GetWidth(); ++x)
        {
            std::cout << MyArray[x][y] << ", ";
        }
        std::cout << '\n';
    }
    std::cout << '\n';
}