Conitec/oP developing an MMOG

Michael Schwarz — Mon, 03 Aug 2009 15:53:33 +0000

JCL posted in the forums today:

Some may have noticed that since the release of A7, Gamestudio support and distribution is not handled by Conitec but by another company, the oP group Germany GmbH.

Old timers may remember that Gamestudio was originally developed by oP group, and eventually sold to Conitec. In the 1990s, the oP group developed several small computer games, advertising games, TV games, and virtual exhibitions. Afterwards my job at Conitec became too time consuming, and the other oP group members had not much time either, so the oP group was put to sleep.

Now after ten years, oP group is starting with game development again. We are currently applying for a contract to develop a large scale MMOG for a certain organization. They have selected the A7 engine for this project. The main reason was the experience that they could set up a well working MMOG server for 350 users very quickly with A7 Pro, with only a few lines of script. However, the project will require some extensions to A7, like the PhysX plugin that’s currently developed by Chris3D, and a MySQL plugin.

Due to our knowledge of A7, we hope to have a good chance to win the development contract. We’ve already got the contract to prepare the project and hire the team of level designers.

Please cross your fingers that we’ll also get the final contract. Development would then start in September. The features implemented in A7 during the next year will become a little MMOG focused. But I guess this will also benefit the community.

Now, congratulations and all. But a MMO-Server in A7? Sounds ridiculous to me. Sure, a client for a MMO in A7/A6 is no problem… But a Server?

Well… let the professionals do their job. Anyway I’m crossing my fingers.

Code Snippet #2

Michael Schwarz — Thu, 05 Jun 2008 11:09:59 +0000

This is actually an old snippet, but hey it was completely commented in German before and with a slight outdated syntax. So here it is: My updated Multiplayer Chat script which I posted in the forums a few times.

It should have commented everything you need to understand the script and give you a little insight into Multiplayer Programming with 3DGS.

If you have any questions about this script. Don’t hesitate to ask!

I always like to start with definitions of the objects we need later in the script, so lets do this now:

font ChatFont = "Arial#12";
  
string STR_Received = "#100";
string STR_Sent = "#100";
string STR_Input = "#100";
  
string STR_ChatLine01 = "#100";
string STR_ChatLine02 = "#100";
string STR_ChatLine03 = "#100";
string STR_ChatLine04 = "#100";
string STR_ChatLine05 = "#100";
  
text TXT_ChatWindow // The "Chatwindow"
{
    strings = 5;
    string = STR_ChatLine01,STR_ChatLine02,STR_ChatLine03,STR_ChatLine04,STR_ChatLine05;
    pos_x = 10;
    pos_y = 10;
    font = ChatFont;
}
  
text TXT_ChatInput // The input line to type new messages
{
    string = STR_Input;
    pos_x = 10;
    pos_y = 100;
    font = ChatFont;
}
  
function chat_init() // Call this function in your MAIN FUNCTION
{
    TXT_ChatWindow.visible = on;
    TXT_ChatInput.visible = on;
}

Now, what do we have got here? Basically all you need for a simple chat. We have defined a font we will use, and as I like Arial quite much, I chose that one. Though it’s not relevant for the script to work properly, so just change it to anything you like.

Next up we have several strings all with a “#100” placeholder, basically, this fills the strings with 100 whitespaces, which is important as there is a bug in 3DGS which sets the max length of a string after the first assignment. So if we’d receive a message like “Hi!”, one of those strings would be further on limited to 3 chars, which is *not* very convenient for a chat.

Also we have the two text objects that will make it able to actually SEE the strings on screen. The first one is for the representation of the chat lines (the received messages) and the second one for the representation of the input line, which will serve us to write.

Also I have included the function that you will need to call to initialize your chat, in the most common case that would be your MAIN function.

Let’s take a look on the very first function with a purpose:

/*
As you can only send strings to the server as client,
we must send any chat message to the serve first
*/
function SendMsgToServer()
{
    // Prepare string
    str_cpy(STR_Sent, player_name); // First, we'll add the player name
    str_cat(STR_Sent, ": "); // then a :
    str_cat(STR_Sent, STR_Input); // and finally the message
    
    // Send string
    send_string(STR_Sent); // Now we send the string to the server
    
    wait(1); // Wait 1 frame for the message to be sent -- VERY IMPORTANT
    
    // Empty the strings to avoid duplication
    str_cpy(STR_Sent, "");
    str_cpy(STR_Input, "");
}

Easy I think, as everything is basically well explained in the comments. This function handles the sending of the chat-line from the client to the server when we send a message. Something as a sidenote as some people don’t understand where the player_name comes from: The string/variable player_name is a predefined value from the Acknex engine, it’s either defined by changing it directly using the “-pl” command line, or with an automatically given name at the start of the engine.

I’d like to add this very important fact at this point: It is VERY important to wait one frame where I indicated it as “VERY IMPORTANT” because if we don’t, the engine cannot send the string before we change it to empty again, or otherwise, if we want to receive it, the string is not filled before we try to read it. This is a very common mistake and produces most of the errors when writing multiplayer games in 3DGS.

Next up, a simple function to handle the input by the client:

function InputText()
{
    if(inkey_active){ return; } // If already active, RETURN!
    
    inkey(STR_Input); // Input focus on STR_Input
    
    if(result == 13) // If input is ended by ENTER
    {
        SendMsgToServer(); // Send message
    }
}
  
on_enter = InputText; // Bind Input function to enter key 

Should be self-explanatory which is why I won’t go any further on this.

Now we have a two-functions part, which might seem a bit ridiculous to you, as both functions seem to be very similar, but there is a small difference BEFORE emptying the received string. Just read the commentaries and you’ll understand it.

function ReceiveMessage() // Function when the client receives messages from the server
{
    wait(1); // wait one frame -- IMPORTANT
    
    /*
     To avoid that a server that has been started as "-sv -cl"
     gets the message twice, use ifndef server;
    */
    ifndef server;
        if(str_len(STR_Received) > 0) // If we received a valid chat message
        {
            // Reorder Chat
            str_cpy(STR_ChatLine01, STR_ChatLine02); // 2 > 1
            str_cpy(STR_ChatLine02, STR_ChatLine03); // 3 > 2
            str_cpy(STR_ChatLine03, STR_ChatLine04); // 4 > 3
            str_cpy(STR_ChatLine04, STR_ChatLine05); // 5 > 4
            str_cpy(STR_ChatLine05, STR_Received); // New message > 5
            
            wait(1); // Wait one frame -- IMPORTANT, as always
            
            str_cpy(STR_Received,""); // Empty the received string
        }
    endif; // Close the ifndef
    
    ifdef server;
        wait(1); // To avoid an empty function. 
    endif;
}
  
on_client = ReceiveMessage; // Bind ReceiveMessage function on the Client-Receive-Data event
  
function ReceiveMessage_Server() // The same function as above, but for the server and slightly changed
{
    wait(1); // wait 1 frame -- IMPORTANT
    
    if(str_len(STR_Sent)>0) // If we got a valid chat message
    {
        // Copy
        str_cpy(STR_Received,STR_Sent);
        
        // Order
        str_cpy(STR_ChatLine01, STR_ChatLine02); // 2 > 1
        str_cpy(STR_ChatLine02, STR_ChatLine03); // 3 > 2
        str_cpy(STR_ChatLine03, STR_ChatLine04); // 4 > 3
        str_cpy(STR_ChatLine04, STR_ChatLine05); // 5 > 4
        str_cpy(STR_ChatLine05, STR_Received); // New message > 5
        
        // IMPORTANT -- DON'T empty the message yet
        // Send it to all clients first!
        send_string(STR_Received);
        
        wait(1); // Wait 1 frame for the message to be sent -- IMPORTANT
        
        // Empty
        str_cpy(STR_Received,"");
        str_cpy(STR_Sent,"");
    }
}
  
on_server = ReceiveMessage_Server; // Bind ReceiveMessage_Server to the Server-Receive-Event

And guess what – That’s it. That’s ALL you need for a simple chat.

In case you are too lazy to type all of this off – which would make it way easier for you to learn – and just wanna mess around with it, here’s the complete download of this script:

chatscript.wdl (3.47 kb) Download!

The 3DGS Nerd » multiplayer

Conitec/oP developing an MMOG

Code Snippet #2