Message Board


Message Board > Fenix / Bennu / Gemix / DIV > DIV is back!... Gemix Studio, the new DIV3

July 23, 2008, 21:01
GINO
None
15 posts
Hi.
I think you haven't seen the difference between Gemix Studio and Bennu yet. Well, maybe when it is more advanced you will see the differences between Gemix Studio (Game development platform) and Bennu, and not only between Gemix (language) and Bennu.
Anyone who is interested in Gemix Studio or who want start developing games can track the project by downloading the free betas for now. We have to work hard at the moment, thanks for your interest and for your politeness.

Bye, GINO.
____________
#
July 23, 2008, 22:57
Sandman
F3n!x0r
1194 posts

I see, you are comparing Gemix Studio with Bennu. I don't think that's a proper comparison, as they are entirely different things. Sure the all-in-one IDE can be awesome, but Bennu is not about any studio (although the language is being enhanced for better 'project' support in IDEs).
So it needs to be redefined what is actually being compared.

Gemix (language) - Bennu (language)
Gemix modules - Bennu modules
Gemix Studio - ...no equivalent (3rd party tools)
These seem proper comparisons to me; are there more?
____________
BennuWiki
Yes, my avatar has grey borders in IE (so get a decent browser)
ROOFLEZ ROOFLEZ
#
July 23, 2008, 23:31
PB
Defender of the faith
630 posts

At some point I stopped reading the replies, since it seemed to become one big Linux/Windows discussion parody.

You asked me the source that was not backwards compatible, and I have it. But please ignore the terrible style of the source, it's old and I was young. I'm already using Gemix to fix up some things, but I post the original (untouched and unclean) code here:


Code:
/*****************************************************************************
* Game:     Solitair
* Genre:    Cards
*****************************************************************************/

compiler_options _case_sensitive;

program Solitaire;
global
    byte cards[53]=7,                       //deck of cards:
    11,12,13,14,15,16,17,18,19,20,21,22,23,
    31,32,33,34,35,36,37,38,39,40,41,42,43,
    51,52,53,54,55,56,57,58,59,60,61,62,63,
    71,72,73,74,75,76,77,78,79,80,81,82,83,
    7;

    byte _row[6,18];
    byte row_position[6];

    byte dragged_cards[12];//cards that are being dragged from the row-stack

    byte position=0;    //current flipped card
    byte dragging=false;//boolean: if true the user is dragging a card
    byte game_won=5;    //0 is true; 5 is false

private
    int count;
begin
    set_mode(360240);
    set_fps(24,0);
    load_fpg("cards.fpg");
    mouse.graph=load_map("mouse.map");
    put_screen(0,1);
    set_deck();
    frame;
    loop
        for(x=0;x<4;x++)
            y=get_id(type finish);
            if((y.graph-10)%20==13)
                count++;
            end
        end
        if(count==4)
            game_won=0;
        end
        if(mouse.left or key(_f2))
            if(game_won!=5 or key(_f2))
                game_won=5;
                position=0;
                mouse.graph=1000;
                restore_type=complete_restore;
                let_me_alone();
                set_deck();
            end
        end
        if(key(_alt) and key(_2) and (key(_l_shift) or key(_r_shift)))
            game_won=0;
        end
        count=0;
        frame;
    end
end

process temp(graph, x, y)
begin
    loop
        frame;
    end
end

/*****************************************************************************
* Process:      deck1()
* Signature:    [no variables]
* Describtion:
* This is the image you click on if you want to flip a card.
*****************************************************************************/

process deck1()
begin
    x=28;
    y=35;
    graph=6;
    loop
        if(collision(type mouse) and mouse.left and not dragging)
            graph=next_position();
            while(mouse.left)
                frame;
            end
        end
        frame;
    end
end

/*****************************************************************************
* Process:      deck2()
* Signature:    [no variables]
* Describtion:
* This process shows the current fliped card (or the previous if the current
* flipped card is on the field.
*****************************************************************************/

process deck2()
private
    byte buffer;
begin
    x=78;
    y=35;
    loop
        graph=cards[position];
        if(graph==0)
            privious_position();
            graph=cards[position];
        end
        if(mouse.left and collision(type mouse) and not (dragging or position==0 or position==53))
            drag(graph, x, y);
            buffer=graph;
            graph=privious_position();
            while(mouse.left)
                frame;
            end
            frame;
            next_position();
            if(cards[position]==buffer)
                graph=buffer;
            else
                graph=privious_position();
            end
        end
        if(game_won!=5)
            buffer=graph;
            graph=0;
            while(game_won!=5)
                frame;
            end
            graph=buffer;
        end
        frame;
    end
end

/*****************************************************************************
* Process:      Finish(byte)
* Signature:    byte number: Identification number of the finish stack
* Describtion:
* The one of four stacks where you should place all your cards to finish.
*****************************************************************************/

process finish(byte number)
private
    int speed_x;
    int speed_y;
begin
    y=35;
    x=141+(number*50)+(number/2);
    graph=7;
    loop
        if(collision(type mouse) and mouse.left and not (dragging or graph==7))
            drag_finish(x, y, id);
        end
        if(game_won==number)
            if((graph-10)%20!=13)
                graph=23+(20*number);
            end
            mouse.graph=0;
            frame;
            restore_type=no_restore;
            while(game_won!=5)
                while((graph-10)%20>1)
                    if(game_won==number)
                        y=35;
                        x=141+(number*50)+(number/2);
                        speed_x=(rand(-2,3)*2)-1;
                        speed_y=1;
                        while(not out_region(id, 0))
                            y+=speed_y;
                            speed_y++;
                            if(y=>209)
                                y=209;
                                speed_y=-speed_y/2;
                            end
                            x+=speed_x;
                            frame;
                        end
                        graph--;
                        game_won++;
                        game_won%=4;
                    else
                        y=-35;
                    end
                    frame;
                end
                frame;
            end
            if(number==4)
                mouse.graph=1000;
                restore_type=complete_restore;
            end
        end
        frame;
    end
end

/*****************************************************************************
* Process:      row(int, int)
* Signature:    int number: identification number
*               (int) x: x coordinate of row
* Describtion:
* This process is used to maintain a row in the playfield.
*****************************************************************************/

process row(int number, x)
private
    byte hidden_cards[5];
    byte nr2=1;
    byte my_drag;
    byte first_card;
    word first_y;
    int count;
begin
    y=113;
    z=1;
    while(row_position[number]<number)
        _row[number, row_position[number]]=6;
        hidden_cards[row_position[number]]=get_card();
        row_position[number]++;
    end
    _row[number, row_position[number]]=get_card();
    graph=_row[number, row_position[number]];
    while(game_won==5)
        y=113;
        first_y=0;
        for(nr2=0;nr2<row_position[number] and row_position[number]!=255;nr2++)
            graphic(_row[number, nr2], x, y, z+1);
            if(_row[number, nr2]==6)
                y+=4;
            else
                if(first_y==0)
                    first_card=nr2;
                    first_y=y-30;
                end
                y+=6;
            end
        end
        if(mouse.left and not(dragging))
            if(graph==6)
                if(collision(type mouse) and _row[number, row_position[number]]==6)
                    _row[number, row_position[number]]=hidden_cards[row_position[number]];
                end
            else
                if(mouse.x>x-22 and mouse.x<x+22)
                    if(mouse.y<y+30 and mouse.y>first_y and row_position[number]!=255)
                        if(mouse.y>y-30)
                            dragged_cards[0]=graph;
                            from count=1 to 12:
                                dragged_cards[count]=0;
                            end
                            row_position[number]--;
                        else
                            if(mouse.y<y-30)
                                from count=0 to 12:
                                    if(((mouse.y-first_y)/6)+first_card+count<19)
                                        dragged_cards[count]=
                                        _row[number, (((mouse.y-first_y)/6)+first_card)+count];
                                        if(dragged_cards[count]!=0)
                                            row_position[number]--;
                                        end
                                    else
                                        dragged_cards[count]=0;
                                    end
                                end
                            end
                        end
                        if(dragged_cards[0]!=0)
                            drag_cards(x, y, id);
                            my_drag=1;
                        end
                    end
                end
            end
            while(mouse.left)
                if(row_position[number]!=255)
                    graph=_row[number, row_position[number]];
                else
                    graph=7;
                end
                frame;
                y=113;
                for(nr2=0;nr2<row_position[number] and row_position[number]!=255;nr2++)
                    graphic(_row[number, nr2], x, y, z+1);
                    if(_row[number, nr2]==6)
                        y+=4;
                    else
                        y+=6;
                    end
                end
            end
        end
        if(row_position[number]!=255)
            graph=_row[number, row_position[number]];
        else
            graph=7;
        end
        if(my_drag==1 and not dragging)
            my_drag=0;
        end
        frame;
    end
end

/*****************************************************************************
* Process:      graphic(int, int, int, int)
* Signature:    (int) graph: graphic number to be shown
*               (int) x: x coordinate of graphic to be shown
*               (int) y: y coordinate of graphic to be shown
*               (int) z: z coordinate of graphic to be shown
* Describtion:
* This process is used to show a graphic without functionality for just one
* frame. This makes it easier for a managing process to display more than one
* graphic.
*****************************************************************************/

process graphic(graph, x, y, z)
begin
    frame;
end

/*****************************************************************************
* Process:      drag(int, int, int)
* Signature:    (int) graph: the graphic that is being dragged over the screen
*               (int) x: x-coordinate where the object to be dragged starts
*               (int) y: y-coordinate where the object to be dragged starts
* Describtion:
* This process is used when a graphic (card) is being dragged over the screen.
*****************************************************************************/

process drag(graph, x, y);
private
    word buffer_x;
    word buffer_y;
    int #ID;
    int source;
    int source_id;
begin
    z=-100;
    dragging=true;
    buffer_x=mouse.x;
    buffer_y=mouse.y;
    while(mouse.left)
        x+=mouse.x-buffer_x;
        y+=mouse.y-buffer_y;
        buffer_x=mouse.x;
        buffer_y=mouse.y;
        frame;
    end

    #ID=collision(type row);
    if(#ID)
        if((#ID.graph-10)%20==((graph-10)%20)+1 and 
                ((#ID.graph<50 and graph>50) or (#ID.graph>50 and graph<50)))
            _row[#ID.x/50, ++row_position[#ID.x/50]]=graph;
            remove_card(graph);
            dragging=false;
            return;
        else
            if(#ID.graph==7 and (graph-10)%20==13)
                _row[#ID.x/50, ++row_position[#ID.x/50]]=graph;
                remove_card(graph);
                dragging=false;
                return;
            end
        end
    else
        #ID=collision(type finish);
        if(#ID)
            if(finish_accepts(#ID.graph, graph))
                #ID.graph=graph;
                remove_card(graph);
                dragging=false;
                return;
            else
                #ID=collision(type finish);
                if(#ID)
                    if(finish_accepts(#ID.graph, graph))
                        #ID.graph=graph;
                        remove_card(graph);
                        dragging=false;
                        return;
                    end
                end
            end
        end
    end
    dragging=false;
end

/*****************************************************************************
* Process:      drag_cards(int, int, int)
* Signature:    (int) x: x-coordinate where the object to be dragged starts
*               (int) y: y-coordinate where the object to be dragged starts
*               int source_id: the id of the source row-stack
* Describtion:
* This process does the same as drag, but is specifically for draging one or
* more cards from the row-stacks.
*****************************************************************************/

process drag_cards(x, y, int source_id)
private
    word buffer_x;
    word buffer_y;
    int count;
    int #ID;
begin
    z=100;
    dragging=true;
    buffer_x=mouse.x;
    buffer_y=mouse.y;
    graph=dragged_cards[0];
    y+=6;
    from count=0 to 12:
        if(dragged_cards[count]!=0)
            y-=6;
        else
            break;
        end
    end
    while(mouse.left)
        x+=mouse.x-buffer_x;
        y+=mouse.y-buffer_y;
        buffer_x=mouse.x;
        buffer_y=mouse.y;
        from count=0 to 12:
            if(dragged_cards[count]!=0)
                graphic(dragged_cards[count], x, y+((count)*6), -100+13-count);
            else
                break;
            end
        end
        frame;
    end

    #ID=collision(type row);
    if(#ID)
        if((#ID.graph-10)%20==((dragged_cards[0]-10)%20)+1 and 
                ((#ID.graph<50 and dragged_cards[0]>50) or (#ID.graph>50 and dragged_cards[0]<50)))
            graph=0;
            from count=0 to 12:
                if(dragged_cards[count]==0)
                    break;
                end
                _row[#ID.x/50, ++row_position[#ID.x/50]]=dragged_cards[count];
            end
            for(count=row_position[source_id.x/50]+1; count=<18; count++)
                _row[source_id.x/50, count]=0;
            end
            dragging=false;
            return;
        else
            if(#ID.graph==7 and (dragged_cards[0]-10)%20==13)
                graph=0;
                from count=0 to 12:
                    if(dragged_cards[count]==0)
                        break;
                    end
                    _row[#ID.x/50, ++row_position[#ID.x/50]]=dragged_cards[count];
                end
                for(count=row_position[source_id.x/50]+1; count=<18; count++)
                    _row[source_id.x/50, count]=0;
                end
                dragging=false;
                return;
            end
        end
    else
        if(dragged_cards[1]==0)
            #ID=collision(type finish);
            if(#ID)
                if(finish_accepts(#ID.graph, graph))
                    #ID.graph=graph;
                    for(count=row_position[source_id.x/50]+1; count=<18; count++)
                        _row[source_id.x/50, count]=0;
                    end
                    dragging=false;
                    return;
                else
                    #ID=collision(type finish);
                    if(#ID)
                        if(finish_accepts(#ID.graph, graph))
                            #ID.graph=graph;
                            for(count=row_position[source_id.x/50]+1; count=<18; count++)
                                _row[source_id.x/50, count]=0;
                            end
                            dragging=false;
                            return;
                        end
                    end
                end
            end
        end
    end

    graph=0;
    from count=0 to 12:
        if(dragged_cards[count]==0)
            break;
        end
        _row[source_id.x/50, ++row_position[source_id.x/50]]=dragged_cards[count];
    end
    dragging=false;
end

/*****************************************************************************
* Process:      drag_finish(int, int, int)
* Signature:    (int) x: x-coordinate where the object to be dragged starts
*               (int) y: y-coordinate where the object to be dragged starts
*               int source_id: the id of the source row-stack
* Describtion:
* This process does the same as drag, but is specifically for draging the top
* card from one of the finish-stacks.
*****************************************************************************/

process drag_finish(x, y, int source_id)
private
    word buffer_x;
    word buffer_y;
    int back_graph;
    int #ID;
begin
    z=-100;
    dragging=true;
    buffer_x=mouse.x;
    buffer_y=mouse.y;
    back_graph=source_id.graph;
    graph=source_id.graph;
    if((source_id.graph-10)%20==1)
        source_id.graph=7;
    else
        source_id.graph--;
    end
    while(mouse.left)
        x+=mouse.x-buffer_x;
        y+=mouse.y-buffer_y;
        buffer_x=mouse.x;
        buffer_y=mouse.y;
        frame;
    end

    #ID=collision(type row);
    if(#ID)
        if((#ID.graph-10)%20==((graph-10)%20)+1 and 
            ((#ID.graph<50 and graph>50) or (#ID.graph>50 and graph<50)))
            _row[#ID.x/50, ++row_position[#ID.x/50]]=graph;
            dragging=false;
            return;
        else
            if(#ID.graph==7 and (graph-10)%20==13)
                _row[#ID.x/50, ++row_position[#ID.x/50]]=graph;
                dragging=false;
                return;
            end
        end
    else
        #ID=collision(type finish);
        if(#ID)
            if(finish_accepts(#ID.graph, graph))
                #ID.graph=graph;
                dragging=false;
                return;
            else
                #ID=collision(type finish);
                if(#ID)
                    if(finish_accepts(#ID.graph, graph))
                        #ID.graph=graph;
                        dragging=false;
                        return;
                    end
                end
            end
        end
    end

    source_id.graph=back_graph;
    dragging=false;
end

/*****************************************************************************
* Function:     shuffle(int)
* Signature:    int times: number of times two random cards get switched
* Return value: [none]
* Describtion:
* This function shuffles the deck of cards stored in the
* global aray: byte cards[51]. You can give a value that indicates the number
* of times two random cards gets switched in the deck.
*****************************************************************************/

function shuffle(int times)
private
    byte buffer[2];
begin
    while(times-->0)
        buffer[0]=rand(1,52);
        buffer[1]=cards[buffer[0]];
        buffer[2]=rand(1,52);
        cards[buffer[0]]=cards[buffer[2]];
        cards[buffer[2]]=buffer[1];
    end
end

/*****************************************************************************
* Function:     set_deck()
* Signature:    [no variables]
* Return value: [none]
* Describtion:
* This function starts essential elements of the game that need to be started
* in every new game.
*****************************************************************************/

function set_deck()
begin
    restore_deck();
    shuffle(1040);
    deck1();
    deck2();
    finish(0);
    finish(1);
    finish(2);
    finish(3);
    row(0,28);
    row(1,78);
    row(2,129);
    row(3,179);
    row(4,230);
    row(5,280);
    row(6,331);
end

/*****************************************************************************
* Function:     restore_deck()
* Signature:    [no variables]
* Return value: number of cards that where missing from the deck.
* Describtion:
* This function restores the stack with flippable cards. This function may
* only be called before there are any cards on the play-feeld, otherwise some
* cards may be doubled in the game.
*****************************************************************************/

function restore_deck()
private
    byte placed;
begin
    from x=0 to 6:
        from y=0 to 18:
            _row[x,y]=0;
        end
        row_position[x]=0;
    end
    y=11;
    while(y<=84)
        placed=0;
        from x=1 to 52:
            if(cards[x]==y)
                y++;
                if((y-10)%20>13)
                    y+=7;
                end
                placed=1;
                break;
            end
        end
        if(placed==0)
            from x=1 to 52:
                if(cards[x]==0)
                    cards[x]=y;
                    z++;
                    break;
                end
            end
        end
    end
    return(z);
end

/*****************************************************************************
* Function:     next_position()
* Signature:    [no variables]
* Return value: graph for deck1();: if all the cards are fliped, deck1()
*               shouldn't show the back of a card, but the table.
* Describtion:
* This function checks and edits everything that must be checked or edited
* when a card is fliped.
*****************************************************************************/

function next_position()
begin
    if(position=>52)
        position%=52;
        return(6);
    end
    while(position<52 and cards[++position]==0)
    end
    if(position==52)
        return(7);
    else
        return(6);
    end
end

/*****************************************************************************
* Function:     privious_position()
* Signature:    [no variables]
* Return value: Graphic of the previous fliped card or the table colour.
* Describtion:
* This function checks and edits everything that must be checked or edited
* when a card is fliped.
*****************************************************************************/

function privious_position()
begin
    if(position==0)
        return(7);
    end
    while(position>1 and cards[--position]==0)
    end
    if(position==0)
        return(7);
    else
        return(cards[position]);
    end
end

/*****************************************************************************
* Function:     remove_card(int)
* Signature:    int del_graph
* Return value: true/false: did the function remove the card?
* Describtion:
* This function removes the card with the given graph (del_graph) from the
* stack of flippable cards.
*****************************************************************************/

function remove_card(int del_graph)
begin
    for(x=0; x<53; x++)
        if(cards[x]==del_graph)
            cards[x]=0;
            return(true);
        end
    end
    return(false);
end

/*****************************************************************************
* Function:     get_card()
* Signature:    [no variables]
* return value: The card taken from the stack of flippable cards.
* Describtion:
* This function takes the first available card out of the stack of flipable
* cards, deletes it and returns the graphic number of that card.
*****************************************************************************/

function get_card()
begin
    x=next_position();
    y=cards[position];
    z=privious_position();
    if(x==7)
        cards[position]=0;
        privious_position();
        return(z);
    else
        next_position();
        cards[position]=0;
        privious_position();
        return(y);
    end
end

/*****************************************************************************
* Function:     finish_accepts(int, int)
* Signature:    int finish_graph: graphic of the finish
*               int object_graph: graphic of the object
* Return value: true/false: does the finish accept the card?
* Describtion:
* This function checks whether the dragged card can be placed on the finish it
* was dragged to.
*****************************************************************************/

function finish_accepts(int finish_graph, int object_graph)
begin
    if(finish_graph==7)
        if((object_graph-10)%20==1)
            return(true);
        else
            return(false);
        end
    end
    if(object_graph==finish_graph+1)
        return(true);
    else
        return(false);
    end
end


Rincewind had edited my post, but the whole point behind this post is that the compiler option _case_sensitive; is not fully backwards compatible. The DIV colorcoding of booleansoup, messes with the capitals...

Sandman: I also edited your post because those long lines kill the forum

[Edited on January 25, 2010 by PB]
____________
#
July 24, 2008, 00:06
PB
Defender of the faith
630 posts

The only thing I needed to do to make this DIV2 source work (if I include the graphics), is removing the line "compiler_options _case_sensitive;", which is the reason I was impressed.
____________
#
July 24, 2008, 00:13
Rincewind
programmer
1545 posts

Quote:
Rincewind had edited my post, but the whole point behind this post is that the compiler option _case_sensitive; is not fully backwards compatible. The DIV colorcoding of booleansoup, messes with the capitals...


Ah, I thought you didn't know you could have them in fancy colors. But yeah the messing with the caps is indeed a bit strange.
____________
Personal website: http://www.loijson.com
#
July 24, 2008, 00:27
PB
Defender of the faith
630 posts

In this case I did know, but as said, I didn't do it because in this case, the code is case sensitive. In other cases the colours would have been fancy and appriciated of course...

Anyway I downloaded the beta 5.2 bit, I indeed missed that tool already, because I had lost the mouse.map that I had made for my solitair game. Unfortunately if I generate the mouse.map with this tool, Gemix tells me:

---------------------------
GEMIX: Runtime error
---------------------------
ERROR 144: A not valid archive of map was loaded.
---------------------------
OK
---------------------------

[Edited on July 24, 2008 by PB]
____________
#
July 24, 2008, 12:44
GINO
None
15 posts
Hi.
We are analyzing the compiler to catch than bug on case_sensitive.

Quote:
ERROR 144: A not valid archive of map was loaded.


Make sure you are opening a map with the same bitdepth as the mode you are running (8bits in this case). MapGenX doesn't convert between bitdepths at the moment, but it will do. Make sure you are loading a 8bit depth image on MapGenX so it will result in a 8bit map when saving.

[Edited on July 24, 2008 by GINO]
____________
#
July 24, 2008, 19:48
PB
Defender of the faith
630 posts

Thanks, that did the trick. Good luck on the project. I'll mention it if I find something curious... Quite funny to be writing a little DIV again, it has been a while :)
____________
#
July 24, 2008, 22:03
Mezzmer
Square-theorist
792 posts

Quoting GINO:
Well, you are also unaware of what Gemix Studio will totally be, so you can't say that Bennu will be an alternative to it. There are people that are already using Gemix in their projects despite they know it is a payment product and that there is Bennu. Each one has his own ideas, yours is to use a free product and we respect it, but you should respect us as well, please.


Why did you post this? I guess you get the put down on me for the sake of Gemix again?

I see Bennu as a free alternative to something like Gemix. Just without the IDE. IT IS NOTHING MORE AT THIS STAGE.

So i thought some friendly discussion about it, based on what YOU said the future of GEMIX is! Not me! So don't push motives under me, mister.

They are both DIV-based languages so why shouldn't I open a thread?

Also, YOU seem to be the one making the comparisons. Sandman had to put you right as I see in the above post.

Low blows GINO.

[Edited on July 25, 2008 by Mezzmer]
____________
#
July 24, 2008, 23:19
PB
Defender of the faith
630 posts

excuse me for going off topic, but where can I get bennu? It doesn't seem to be on the links page or on the first page of google? Is it also backwards compatible with DIV2? Could I compile my solitair game in it too?

I've been away for a while, so I don't know these things...

EDIT: Found it, it appears to be a variation on Fenix? Anyway, it does not compile my code. Which is not a bad thing if backwards compatibility is not the aim. Or if it is because it is not finished yet (Gemix doesn't support some DIV2 things yet eigher...)

[Edited on July 24, 2008 by PB]
____________
#
July 25, 2008, 10:07
Dennis
どこかにいる
2092 posts

I don't think it's compatible with DIV at all. I don't think it matters what is "better". Neither? It's only a matter of what you prefer.
____________
Kwakkel
#
August 24, 2008, 13:24
GINO
None
15 posts
Hi.

We have released a new free update to the beta 5. You can download it here:
http://forum.divsite.net/viewthread.php?tid=6218

--------
PB
--------
The bugs you have reported are now fixed. Thanks a lot for the report.
____________
#
August 24, 2008, 22:49
PB
Defender of the faith
630 posts

You're welcome. Honoustly I haven't really picked it up again much. Coincidentally I checked the forum if there where any new replies on this thread, but I'm kind of off the soup again... Which is a good thing for me...

If I however feel like programming in my free time (which is an odd thing, since I'm a proffesional programmer now) I'd let you know if I find something...
____________
#
October 2, 2008, 17:37
GINO
None
15 posts
Hi people.
Finally we have opened the official Gemix Studio forum. Anyone who is interested in the project can sign up here:
http://www.gemixstudio.com/forums

The forum is still incomplete, but is already functional.

Bye.
____________
#
October 2, 2008, 19:27
Htbaa
Perl
368 posts

Quote:
This board has no forums.

____________
blog.htbaa.com
#
October 2, 2008, 20:04
GINO
None
15 posts
At the moment, you must be registered and logged to view forums and post.

[Edited on October 2, 2008 by GINO]
____________
#
October 11, 2008, 21:51
GINO
None
15 posts
Hi, after some weeks of maintenance we have opened the forum to everybody. However, you will have to sign up and log in to post. Thanks.
____________
#
April 22, 2009, 19:29
GINO
None
15 posts
Hi.

We have released a new free beta 5.5 of Gemix Studio. This beta comes with a better temporal IDE and temporal editors for MAP and FPG. You can download it here:
http://www.gemixstudio.com/for … ?f=64&t=138

Thanks, GINO

[Edited on April 22, 2009 by GINO]
____________
#
April 22, 2009, 19:53
Mezzmer
Square-theorist
792 posts

Bennu will be better. :3
____________
#
April 22, 2009, 20:07
CicTec
Whiskered
49 posts
Hi at all.

Quoting Square:
Bennu will be better. :3

Mr. Square...
You still intend to make controversy and post offensive ?
You know what it means to respect and good manners ?

possibly not familiar with the computer world, a FREE program is never more than an equivalent commercially

In any case you can not say what he said without seeing both finished programs and I think they are both the beta at this time

PD: I apologize to all the moderators for the harsh words used in the post, but it is time to stop all these offenses
____________
#
April 22, 2009, 21:06
Mezzmer
Square-theorist
792 posts

Sorry, i was being childish. :9

But Bennu is better.

[Edited on April 22, 2009 by Mezzmer]
____________
#
April 22, 2009, 21:16
CicTec
Whiskered
49 posts
bennu is not better, just more advanced at the time, having more years of development inherited from Fenix, but Gemix is more advanced than in other aspects to it, this is the difference
____________
#
April 22, 2009, 21:19
Mezzmer
Square-theorist
792 posts

With a selling point like that. Can i argue?
____________
#
April 22, 2009, 21:19
Sandman
F3n!x0r
1194 posts

Perhaps some benchmarks are in order, stressing the VM.

Quoting CicTec:
a FREE program is never more than an equivalent commercially
I don't understand where you get this idea.

Quoting CicTec:
bennu is not better, just more advanced at the time, having more years of development inherited from Fenix, but Gemix is more advanced than in other aspects to it, this is the difference

I'd really want to know the actual differences. What parts of either are better than the other? Maybe the aforementioned benchmarks are a good place to start?
____________
BennuWiki
Yes, my avatar has grey borders in IE (so get a decent browser)
ROOFLEZ ROOFLEZ
#
April 22, 2009, 21:43
Htbaa
Perl
368 posts

Drop the attitude already Square.
____________
blog.htbaa.com
#

Page 1 , 2 , 3 , 4 , 5 , 6


Message Board > Fenix / Bennu / Gemix / DIV > DIV is back!... Gemix Studio, the new DIV3

Quick reply


You must log in or register to post.
Copyright © 2005 Booleansoup.com
Questions? Comments? Bug reports? Contact us!