Daodan/MSVC/Flatline.c

#include "Flatline.h"
#include "Oni_Character.h"
#include "Flatline_Client.h"
#include "Flatline_Server.h"
#include "Flatline_Events.h"
#include <Windows.h>
//#include <sys/time.h>
#include <time.h>
#include <float.h>
#define isnan(x) ((x) != (x))
uint32_t last1 = 0; uint32_t last2 = 0;
player_info Players[MAX_PLAYERS] = {{0}, {0}, {0}, {0}};
player_info * PlayerList[MAX_CONNECTIONS] = {0};
multiplayer_status MultiplayerStatus;
unsigned int lastPingTime;

const char * Rejection_Messages[][255] = {
        {"Server is full"},
        {"-2"},
        {"-3"},
        {"-4"},
        {"-5"},
};

#define BETTER_SYNC

bool FLrServer_PacketCallback(char* data, int datalen, int from)
{
        int i, j;
        bool found_player = 0;
        flatline_packet * packet = (flatline_packet*)data;
        static int recieved = 0;
        sockaddr_in sender;
        sender.sin_family = AF_INET;
        sender.sin_port = htons(27777);
        sender.sin_addr = *((struct in_addr*)(int*)&from);


        //packet->data[datalen] = '\0';

        //DDrConsole_PrintF("Packet \r%d recieved from %i",  ++recieved, from);


        //if data[0] != CONNECT_SEND, search in playerlist for ip address


        switch(packet->id) {
                flatline_packet connect_recv;
                player_info * playah;
                //rewrite this when we get TCP support.
                //rewrite this before we get TCP support*
                //the way of seeing if there is room for players sucks.
        case CONNECT_SEND:
                ;

                connect_recv.id = CONNECT_REPLY;

                //if(Players[i].ip == sender.sin_addr.S_un.S_addr) break; //needs to send an error message
                sender.sin_addr.S_un.S_addr = htonl(sender.sin_addr.S_un.S_addr);
                playah = FLrServer_AddPlayer(from,packet->connect_send.name, 0, 0);
                DDrConsole_PrintF("%s connected from %s", packet->connect_send.name, inet_ntoa(sender.sin_addr ) );
                if(!((int)playah > -5 && (int)playah <= 0)) {
                        flatline_packet new_char = {0};
                        CharacterObject* Char;
                        connect_recv.connect_reply.goodtogo = 1;
                        connect_recv.connect_reply.player_slot = playah->list_slot;
                        DDrConsole_PrintF("Slot: %i", playah->list_slot);

                        //sending this several times to make sure it gets through. Really need to make up some form of packet tracking.
                        NetTCPServer_Send((sockaddr *) &sender, (char*)&connect_recv, sizeof(connect_reply) + FLATLINE_HEADER);
/*                      NetTCPServer_Send((sockaddr *) &sender, (char*)&connect_recv, sizeof(connect_reply) + FLATLINE_HEADER);
                        NetTCPServer_Send((sockaddr *) &sender, (char*)&connect_recv, sizeof(connect_reply) + FLATLINE_HEADER);
                        NetTCPServer_Send((sockaddr *) &sender, (char*)&connect_recv, sizeof(connect_reply) + FLATLINE_HEADER);
                        NetTCPServer_Send((sockaddr *) &sender, (char*)&connect_recv, sizeof(connect_reply) + FLATLINE_HEADER);
                        Sleep(100);
                        */
                        new_char.id = NEW_PLAYER;
                        Char = &new_char.new_player.Character;
                        memset(Char, 0, sizeof(CharacterObject));
                        Char->Header.Type = 'CHAR';
                        Char->OSD.Options = chr_dontaim;
                        for(j = 0; j < max_connections; j++) {
                                if(PlayerList[j] != 0) {
                                        new_char.new_player.Playernumber = j;
                                        sprintf(Char->OSD.Name,"%s",PlayerList[j]->name);

                                        sprintf(Char->OSD.Class, "%s", TMrInstance_GetInstanceName(PlayerList[j]->Chr->ONCC));
                                        DDrConsole_PrintF("Class %s", Char->OSD.Class );

                                        sprintf(Char->OSD.Class, "konoko_generic");
                                        NetTCPServer_Send((sockaddr *) &sender, (char*)&new_char, sizeof(new_player) + FLATLINE_HEADER );
                                }

                        }
                }
                else {
                        //fix the error messages...
                        DDrConsole_PrintF("Server is full. :(");
                        connect_recv.connect_reply.goodtogo = 0;
                        sender.sin_addr.S_un.S_addr = htonl(sender.sin_addr.S_un.S_addr);
                        memcpy(&connect_recv.connect_reply.message,"Server is full.", sizeof("Server is full."));
                        NetTCPServer_Send((sockaddr *) &sender, (char*)&connect_recv, sizeof(bool)*2 + FLATLINE_HEADER + sizeof("Server is full."));    

                } 


                break;
        case CONNECT_REPLY:
                break;  //do nothing...a server shouldn't recieve this type of packet.
        case MESSAGE:
                for(i = 0; i < MAX_PLAYERS; i++) {
                        //DDrConsole_PrintF("%i : %i | %s : %s", from, Players[i].ip, inet_ntoa(*(struct in_addr*)&from), inet_ntoa(*(struct in_addr*)&(Players[i].ip)));
                        if(Players[i].ip == sender.sin_addr.S_un.S_addr) {
                                found_player = 1;
                                break;
                        }       
                }
                if(found_player == 0) return true;
                else {
                        char message_buffer[512] = {0};
                        flatline_packet message;
                        int message_size;
                        data[datalen] = 0;

                        DDrConsole_PrintF("%s: %s", Players[i].name, packet->data);
                        sprintf(message_buffer, "%s: %s", Players[i].name, packet->data);

                        message.id = MESSAGE;
                        message_size = sprintf(message.data, "%s", message_buffer);
                        COrMessage_Print(message_buffer, "chat", 0);
                        UDPServer_SendToAll(&message, message_size + 1 + FLATLINE_HEADER);
                        break;
                }
        case CHANGE_NAME:
                ; //wtf, needed or i get an error.
        //      DDrConsole_PrintF("Changing Name to: %s", packet->data);
                for(i = 0; i < MAX_PLAYERS; i++) {
                        if(PlayerList[i] && PlayerList[i]->ip == sender.sin_addr.S_un.S_addr) {
                                found_player = 1;
                                break;
                        }       
                }
                if(found_player == 0) break;
                else {
                        bool name_exists = 0;
                        for(j = 0; j < MAX_PLAYERS; j++) {
                                if(PlayerList[j] && !strcmp(packet->data, PlayerList[j]->name)) {
                                        name_exists = 1;
                                        break;
                                }
                        }
                        if(!name_exists) {
                                FLsUpdateName( i, packet->data );
                        }
                        break;
                }
        case PLAYER_INPUT:

                for(i = 0; i < max_connections; i++) {
                        if(PlayerList[i] != 0 && PlayerList[i]->ip == sender.sin_addr.S_un.S_addr) {
                                found_player = 1;
                                break;
                        }       
                }

                if(found_player == 0) break;
                else {
                        input_struct * packet_input = &packet->input_struct;


                        PlayerList[i]->InputFromClient.Actions1 = packet_input->Actions1;
                        PlayerList[i]->InputFromClient.Actions2 = packet_input->Actions2;
                        PlayerList[i]->InputFromClient.MouseDeltaX = packet_input->MouseDeltaX;
                        PlayerList[i]->InputFromClient.MouseDeltaY = packet_input->MouseDeltaY;
                        PlayerList[i]->LastInputTime = packet_input->Time;

                        break;
                }
        case PK_PONG:
                for(i = 0; i < max_connections; i++) {
                        if(PlayerList[i] != 0 && PlayerList[i]->ip == sender.sin_addr.S_un.S_addr) {
                                found_player = 1;
                                break;
                        }       
                }

                if(found_player == 0) break;
                if(packet->ping != lastPingTime)
                {
                        PlayerList[i]->Ping = 999;
                }
                else
                {
                        PlayerList[i]->Ping = GetTickCount() - packet->ping;
                }
                break;
        default:
                DDrConsole_PrintF("Warning, recieved badly formed packet!");
                break;
        }
        return true;
}

bool FLrServer_Run()
{
        // Get the local hostname
        char szHostName[255];
        struct hostent *host_entry;
        gethostname(szHostName, 255);

        host_entry=gethostbyname(szHostName);
        DDrConsole_PrintF("Server started at %s...", inet_ntoa (*(struct in_addr *)*host_entry->h_addr_list));
        return NetUDPServer_Listen(27777, FLrServer_PacketCallback);
}

short TRrAnimation_GetType(char* anim)
{
        return *(short*)(anim + 0x15A);
}

void ONrCharacter_SetAnimationInternal(Character* Char, ActiveCharacter* AChar,
        short inFromState, short inNextAnimType, const void *TRAM)
{
        ONCC            *ONCC   = Char->ONCC;
        void            *TRAC   = ONCC->TRAC;
        short   index = Char->Number;
        short animType;

        if (TRAM == 0) return;

        animType = TRrAnimation_GetType(TRAM);

        AChar->Animation = TRAM;
        AChar->Frame = 0;
        AChar->AnimationFromState = inFromState;
        AChar->AnimationType = animType;

        AChar->NextAnimationType= inNextAnimType;
        AChar->AnimationToState = TRrAnimation_GetTo(TRAM);

        return;
}


//wtf, this needs cleaned up...
player_info *FLr_FindEmptySlot() {
        int j;
        for(j = 0; j < MAX_PLAYERS; j++) {
                if (Players[j].ip == 0) {
                        return &Players[j];
                }
        }
        return 0;
}

extern uint16_t max_connections;
uint16_t FLr_FindEmptyListSlot() {
        int j;
        for(j = 0; j < max_connections; j++) {
                if (PlayerList[j] == 0) {
                        return j;
                }
        }
        return -1;
}
typedef struct
{
        uint16_t x;
        uint16_t y;

} IMtPoint2D;
static flatline_packet cache_input = {0};


void * ONICALL FLrInput_Update_Keys(void) 
{
        uint32_t i;
        flatline_packet all_input = {0};
        int16_t InputIndex = 0;
        
        if(client_connected) 
        {
                int sent_bytes;
                flatline_packet input_packet = {0};

                FLrClient_GetPackets();

                input_packet.id = PLAYER_INPUT;
                input_packet.input_struct.Time = ONgGameState->GameTime;
                input_packet.input_struct.Actions1 = ((GameState*)(ONgGameState))->Input.Current.Actions1;
                input_packet.input_struct.Actions2 = ((GameState*)(ONgGameState))->Input.Current.Actions2;
                input_packet.input_struct.MouseDeltaX = ((GameState*)(ONgGameState))->Input.MouseDeltaX;
                input_packet.input_struct.MouseDeltaY = ((GameState*)(ONgGameState))->Input.MouseDeltaY;

                sent_bytes = NetUDPSocket_Send(client_sock,(sockaddr *) &address, (char*)&input_packet, sizeof(input_struct) + FLATLINE_HEADER);

                //return ONgGameState;
        }


        if(!(server_started || client_connected)) return ONgGameState;


        if(server_started)
        {
                if(ONgGameState->GameTime % 120 == 0)
                {
                        FLsPingAll();
                }

                if(PlayerList[0])
                {
                        PlayerList[0]->InputFromClient.Actions1 = ONgGameState->Input.Current.Actions1;
                        PlayerList[0]->InputFromClient.Actions2 = ONgGameState->Input.Current.Actions2;
                        PlayerList[0]->InputFromClient.MouseDeltaX = ONgGameState->Input.MouseDeltaX;
                        PlayerList[0]->InputFromClient.MouseDeltaY = ONgGameState->Input.MouseDeltaY;
                }
                FLsSendPlayerData();
        }
        for(i = 0; i < max_connections; i++) {
                ActiveCharacter * Active_Player;
                Character* Player;
                GameInput * Active_Input;
                if(PlayerList[i] == 0) continue;
                
                Player = PlayerList[i]->Chr;
                Active_Player = ONrGetActiveCharacter( PlayerList[i]->Chr);

                if(!Player)
                {
                        DDrConsole_Print("Warning, missing Character!");
                        continue;
                }


                //Set the health properly first.
                if( client_connected && DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Health) )
                {
                        PlayerList[i]->Chr->MaxHealth = PlayerList[i]->Health.MaxHealth;
                        ONrCharacter_SetHitPoints(  PlayerList[i]->Chr, PlayerList[i]->Health.Health);
                        PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_Health );
                }
                //If the player is dead
                if( PlayerList[i]->Chr->Health == 0 )
                        
                {
                        const short TicksToRespawn = 3 * 60;
                        
                        //Permanently kill off dumb AI
                        if(PlayerList[i]->flags & PF_SCRIPTEDAI)
                        {
                                FLrPlayerDisconnect( i );
                                continue;
                        }

                        //Just to know if we have started counting off the respawn
                        if(PlayerList[i]->state != STATE_DEAD)
                        {
                                PlayerList[i]->state = STATE_DEAD;
                                PlayerList[i]->DeathTime = ONgGameState->GameTime;
                                if(i == client_slot)
                                {
                                        ONrGameState_Timer_Start( "", TicksToRespawn  );
                                }

                                if(server_started)
                                {
                                        FLsPublic_Event( EV_KILLED, &i );       
                                }
                                
                        }

                        //Server respawning
                        if(server_started)
                        {
                                int Actions;
                                if(i == 0)
                                {
                                        Actions =  ONgGameState->Input.Current.Actions1;
                                }
                                else
                                {
                                        Actions = PlayerList[i]->InputFromClient.Actions1;
                                }

                                if(ONgGameState->GameTime - PlayerList[i]->DeathTime > TicksToRespawn && 
                                        (Actions & (Action_Punch | Action_Kick)) )
                                {
                                        FLrPlayerRespawn( i );
                                        
                                        FLsPublic_Event( EV_RESPAWN, &i );
                                }
                                else
                                {
                                        continue;
                                }
                        }
                        else //clients?!
                        {
                                continue;
                        }
                }

                PlayerList[i]->state = STATE_ALIVE;

                if( DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Facing ) )
                {
                        PlayerList[i]->Chr->Facing = PlayerList[i]->Facings.Facing;                                     
                        PlayerList[i]->Chr->DesiredFacing = PlayerList[i]->Facings.DesiredFacing;
                        PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_Facing );
                }

                if(Active_Player == 0) continue;

                if( client_connected && DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Position) )
                {
                        Active_Player->PhyContext->Position = PlayerList[i]->Position;
                        
                        PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_Position );
                }


                if (!(Player->Flags & ONcCharacterFlag_BeingThrown) &&
                        DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Animation) && (PlayerList[i]->Animation))
                {
                        // get a pointer to the animation

                        
                        if (PlayerList[i]->Animation != Active_Player->Animation)
                        {

                                ///////////////////////////////////
                                //TODO: Check age of animation
                                ///////////////////////////////////

                                // set the characters animation
                                /*ONrCharacter_SetAnimationInternal(Player,
                                Active_Player,
                                Active_Player->AnimationToState,
                                0,
                                Animation);*/
                                //ONrCharacter_NewAnimationHook(Player, Active_Player);
                                ONrCharacter_SetAnimationExternal(Player, TRrAnimation_GetFrom(PlayerList[i]->Animation), PlayerList[i]->Animation, 0);
                                //ONrCharacter_NewAnimationHook(Player, Active_Player);
                        }
                        
                        
                }
                PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_Animation );

                //Don't update the frame if we are waiting to change the animation
                if(DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_FramePing) && PlayerList[i]->Frame != -1 
                        //&& !DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Animation) 
                        )
                {
                        if( abs(PlayerList[i]->Frame - Active_Player->Frame) > 2 )
                        {
                                short AnimationLength;
                                AnimationLength = TRrAnimation_GetDuration(Active_Player->Animation);
                                if (PlayerList[i]->Frame >= AnimationLength)
                                {
                                        Active_Player->Frame = AnimationLength - 1;
                                        //Active_Player->Frame = 0;
                                }
                                else
                                {
                                        Active_Player->Frame = PlayerList[i]->Frame;
                                }
                        }
                        PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_FramePing );
                }

                //Increment frame in case we were waiting
                PlayerList[i]->Frame++;

                if (DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Throws) 
                        && PlayerList[i]->ThrowData.throwName[0] != 0)
                {
                        if(PlayerList[PlayerList[i]->ThrowData.throwing])
                        {
                                short throwTarget = PlayerList[PlayerList[i]->ThrowData.throwing]->spawnnumber;
                                if ((throwTarget != Active_Player->throwing) &&
                                        (PlayerList[i]->ThrowData.throwFrame < 10))
                                {
                                        void    *throw_animation;
                                        ActiveCharacter* Target;
                                        // get the animation

                                        TMrInstance_GetDataPtr(
                                                'TRAM',
                                                PlayerList[i]->ThrowData.throwName,
                                                &throw_animation);
                                        //if (error) return;

                                        // set the throw target
                                        Active_Player->ThrowTargetCharacter = &ONgGameState->CharacterStorage[throwTarget];
                                        Target = ONrGetActiveCharacter(Active_Player->ThrowTargetCharacter);
                                        if ((Target->Animation != throw_animation) &&
                                        //      (OldAnimation != Animation) &&
                                                !(Active_Player->ThrowTargetCharacter->Flags & ONcCharacterFlag_BeingThrown))
                                        {
                                                // set the throw variables
                                                Active_Player->targetThrow      = throw_animation;
                                                Active_Player->throwing         = throwTarget;

                                                // run the throw
                                                ONrCharacter_NewAnimationHook(Player, Active_Player);

                                                if (Active_Player->ThrowTargetCharacter)
                                                {
                                                        Target->Frame += 2;
                                                        Target->thrownBy = Player->Number;
                                                }
                                        }
                                }
                        }
                        else
                        {
                                DDrConsole_PrintF("Warning, tried to throw nonexistant player %hi", 
                                        PlayerList[i]->ThrowData.throwing );
                        }
                } 

                //Always discard old throw data, even if it isnt applied
                PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_Throws );

                //Active_Player->PlayingFilm.Flags = 1;
                Active_Input = &(Active_Player->Input);

                if( (server_started && i !=0)  || !server_started ) 
                {
                        Active_Input->Stop.Actions1 = ~PlayerList[i]->Input.Actions1 & Active_Input->Current.Actions1;
                        Active_Input->Stop.Actions2 = ~PlayerList[i]->Input.Actions2 & Active_Input->Current.Actions2;
                        Active_Input->Start.Actions1 = ~Active_Input->Current.Actions1 & PlayerList[i]->Input.Actions1;
                        Active_Input->Start.Actions2 = ~Active_Input->Current.Actions2 & PlayerList[i]->Input.Actions2;

                        Active_Input->Current.Actions1 = PlayerList[i]->Input.Actions1;
                        Active_Input->Current.Actions2 = PlayerList[i]->Input.Actions2;
                        Active_Input->Stopped.Actions1 = ~Active_Input->Current.Actions1;
                        Active_Input->Stopped.Actions2 = ~Active_Input->Current.Actions2;
                        Active_Input->MouseDeltaX = PlayerList[i]->Input.MouseDeltaX;
                        Active_Input->MouseDeltaY = PlayerList[i]->Input.MouseDeltaY;
                } 
                
                //Check for character switching requests
                if(server_started && PlayerList[i]->Chr->Health != 0 && PlayerList[i]->InputFromClient.Actions1 & Action_Block && PlayerList[i]->ShapeshiftCooldown < ONgGameState->GameTime)
                {
                        int error;


                        ONCC *newClass;
                        short numClasses = (short)TMrInstance_GetTagCount('ONCC');
                        /*
                        if(Active_Player->Input.Start.Actions1 & Action_Block)
                        {
                                //This might not be getting hit. Find out why, eh?
                                PlayerList[i]->ShapeshiftCooldown = ONgGameState->GameTime + 15;
                        }
                        else
                        {
                                PlayerList[i]->ShapeshiftCooldown = ONgGameState->GameTime + 5;
                        }
                        */
                        if (PlayerList[i]->InputFromClient.Actions1 & Action_Crouch) {
                                Player->ONCCnumber += numClasses - 1;
                        }
                        else {
                                Player->ONCCnumber += 1;
                        }

                        if (numClasses > 0) {
                                Player->ONCCnumber = Player->ONCCnumber % numClasses;

                                error = TMrInstance_GetDataPtr_ByNumber('ONCC', Player->ONCCnumber, &newClass); 

                                if ((newClass != NULL) && (!error)) {
                                        ONrCharacter_SetCharacterClass(Player, newClass);
                                }
                        }

                }


        }
        
        MultiplayerStatus.PleaseUpdateAllPlayers = 0;
        return ONgGameState;
}

void FLrPlayerDisconnect( int Player )
{
        if(server_started)
        {
                //FLsPublic_Event(EV_DISCONNECT, &Player );
                MultiplayerStatus.PleaseUpdateAllPlayers = 1;
        }
        //Kill off the character in another function, please
        //ONrCharacter_SetHitPoints(  PlayerList[Player]->Chr, 0);

        memset(PlayerList[Player], 0, sizeof(player_info));
        PlayerList[Player] = 0;


        return;
}

void FLrPlayerRespawn( int Player )
{
        PlayerList[Player]->state = STATE_ALIVE;
        ONrCorpse_Create(PlayerList[Player]->Chr);
        ONrCharacter_SetHitPoints(  PlayerList[Player]->Chr, PlayerList[Player]->Chr->MaxHealth );
}


void* ScoreboardInstance = 0;
void FLrRun_Scores()
{
        if(client_connected || server_started)
        {
                if(!ScoreboardInstance){
                        void* TSFFTahoma;
                        TMrInstance_GetDataPtr( 'TSFF', "Tahoma", &TSFFTahoma);
                        TSrContext_New( TSFFTahoma, 7, 1, 1,  0, &ScoreboardInstance);
                }
                if(ScoreboardInstance){
                        const int white =       0x00FFFFFF;
                        const int green =       0x0000FF00;
                        const int red =         0x00FF0000;
                        int i;
                        char DrawString[255];
                        const int LineHeight = 15;
                        IMtPoint2D DrawLocation = {20, 20};
                        TSrContext_SetShade(ScoreboardInstance, white);
                        TSrContext_DrawText(ScoreboardInstance, "Oni Flatline build " __DATE__ " " __TIME__, 255, 0, &DrawLocation);
                        DrawLocation.y += LineHeight;
                        TSrContext_DrawText(ScoreboardInstance, "Name", 255, 0, &DrawLocation);
                        DrawLocation.x += 150;
                        TSrContext_DrawText(ScoreboardInstance, "Score", 255, 0, &DrawLocation);
                        DrawLocation.x += 50;
                        TSrContext_DrawText(ScoreboardInstance, "Ping", 255, 0, &DrawLocation);
                        for(i = 0; i <MAX_PLAYERS; i++)
                        {
                                if(PlayerList[i] == 0 || PlayerList[i]->Chr == 0) continue;

                                DrawLocation.x = 20;
                                DrawLocation.y += LineHeight;

                                if(PlayerList[i]->Chr && PlayerList[i]->Chr->Health == 0) 
                                {
                                        TSrContext_SetShade(ScoreboardInstance, red);
                                }
                                else if (i == client_slot)
                                {
                                        TSrContext_SetShade(ScoreboardInstance, green);
                                }
                                TSrContext_DrawText(ScoreboardInstance, PlayerList[i]->name, 255, 0, &DrawLocation);
                                TSrContext_SetShade(ScoreboardInstance, white);
                                DrawLocation.x += 150;
                                sprintf(DrawString, "%i", PlayerList[i]->Chr->Damage);
                                TSrContext_DrawText(ScoreboardInstance, DrawString, 255, 0, &DrawLocation);
                                DrawLocation.x += 50;
                                sprintf(DrawString, "%i", PlayerList[i]->Ping);
                                TSrContext_DrawText(ScoreboardInstance, DrawString, 255, 0, &DrawLocation);
                        }
                }
        }
}

bool FlatlineInitialize()
{
        
        memset( Players, 0, sizeof( player_info ) * MAX_PLAYERS );
        memset( PlayerList, 0, 4 * MAX_PLAYERS );
        memset( &MultiplayerStatus, 0, sizeof( multiplayer_status ));
        return 1;
}
Revision:	584
Committed:	Mon Jan 24 06:45:07 2011 UTC (14 years, 10 months ago) by gumby
Content type:	text/x-csrc
File size:	20032 byte(s)
Log Message:	Almost working rework
#	Content
1	#include "Flatline.h"
2	#include "Oni_Character.h"
3	#include "Flatline_Client.h"
4	#include "Flatline_Server.h"
5	#include "Flatline_Events.h"
6	#include <Windows.h>
7	//#include <sys/time.h>
8	#include <time.h>
9	#include <float.h>
10	#define isnan(x) ((x) != (x))
11	uint32_t last1 = 0; uint32_t last2 = 0;
12	player_info Players[MAX_PLAYERS] = {{0}, {0}, {0}, {0}};
13	player_info * PlayerList[MAX_CONNECTIONS] = {0};
14	multiplayer_status MultiplayerStatus;
15	unsigned int lastPingTime;
16
17	const char * Rejection_Messages[][255] = {
18	{"Server is full"},
19	{"-2"},
20	{"-3"},
21	{"-4"},
22	{"-5"},
23	};
24
25	#define BETTER_SYNC
26
27	bool FLrServer_PacketCallback(char* data, int datalen, int from)
28	{
29	int i, j;
30	bool found_player = 0;
31	flatline_packet * packet = (flatline_packet*)data;
32	static int recieved = 0;
33	sockaddr_in sender;
34	sender.sin_family = AF_INET;
35	sender.sin_port = htons(27777);
36	sender.sin_addr = ((struct in_addr)(int*)&from);
37
38
39	//packet->data[datalen] = '\0';
40
41	//DDrConsole_PrintF("Packet \r%d recieved from %i", ++recieved, from);
42
43
44
45	//if data[0] != CONNECT_SEND, search in playerlist for ip address
46
47
48
49
50	switch(packet->id) {
51	flatline_packet connect_recv;
52	player_info * playah;
53	//rewrite this when we get TCP support.
54	//rewrite this before we get TCP support*
55	//the way of seeing if there is room for players sucks.
56	case CONNECT_SEND:
57	;
58
59	connect_recv.id = CONNECT_REPLY;
60
61	//if(Players[i].ip == sender.sin_addr.S_un.S_addr) break; //needs to send an error message
62	sender.sin_addr.S_un.S_addr = htonl(sender.sin_addr.S_un.S_addr);
63	playah = FLrServer_AddPlayer(from,packet->connect_send.name, 0, 0);
64	DDrConsole_PrintF("%s connected from %s", packet->connect_send.name, inet_ntoa(sender.sin_addr ) );
65	if(!((int)playah > -5 && (int)playah <= 0)) {
66	flatline_packet new_char = {0};
67	CharacterObject* Char;
68	connect_recv.connect_reply.goodtogo = 1;
69	connect_recv.connect_reply.player_slot = playah->list_slot;
70	DDrConsole_PrintF("Slot: %i", playah->list_slot);
71
72	//sending this several times to make sure it gets through. Really need to make up some form of packet tracking.
73	NetTCPServer_Send((sockaddr ) &sender, (char)&connect_recv, sizeof(connect_reply) + FLATLINE_HEADER);
74	/* NetTCPServer_Send((sockaddr ) &sender, (char)&connect_recv, sizeof(connect_reply) + FLATLINE_HEADER);
75	NetTCPServer_Send((sockaddr ) &sender, (char)&connect_recv, sizeof(connect_reply) + FLATLINE_HEADER);
76	NetTCPServer_Send((sockaddr ) &sender, (char)&connect_recv, sizeof(connect_reply) + FLATLINE_HEADER);
77	NetTCPServer_Send((sockaddr ) &sender, (char)&connect_recv, sizeof(connect_reply) + FLATLINE_HEADER);
78	Sleep(100);
79	*/
80	new_char.id = NEW_PLAYER;
81	Char = &new_char.new_player.Character;
82	memset(Char, 0, sizeof(CharacterObject));
83	Char->Header.Type = 'CHAR';
84	Char->OSD.Options = chr_dontaim;
85	for(j = 0; j < max_connections; j++) {
86	if(PlayerList[j] != 0) {
87	new_char.new_player.Playernumber = j;
88	sprintf(Char->OSD.Name,"%s",PlayerList[j]->name);
89
90	sprintf(Char->OSD.Class, "%s", TMrInstance_GetInstanceName(PlayerList[j]->Chr->ONCC));
91	DDrConsole_PrintF("Class %s", Char->OSD.Class );
92
93	sprintf(Char->OSD.Class, "konoko_generic");
94	NetTCPServer_Send((sockaddr ) &sender, (char)&new_char, sizeof(new_player) + FLATLINE_HEADER );
95	}
96
97	}
98	}
99	else {
100	//fix the error messages...
101	DDrConsole_PrintF("Server is full. :(");
102	connect_recv.connect_reply.goodtogo = 0;
103	sender.sin_addr.S_un.S_addr = htonl(sender.sin_addr.S_un.S_addr);
104	memcpy(&connect_recv.connect_reply.message,"Server is full.", sizeof("Server is full."));
105	NetTCPServer_Send((sockaddr ) &sender, (char)&connect_recv, sizeof(bool)*2 + FLATLINE_HEADER + sizeof("Server is full."));
106
107	}
108
109
110	break;
111	case CONNECT_REPLY:
112	break; //do nothing...a server shouldn't recieve this type of packet.
113	case MESSAGE:
114	for(i = 0; i < MAX_PLAYERS; i++) {
115	//DDrConsole_PrintF("%i : %i \| %s : %s", from, Players[i].ip, inet_ntoa((struct in_addr)&from), inet_ntoa((struct in_addr)&(Players[i].ip)));
116	if(Players[i].ip == sender.sin_addr.S_un.S_addr) {
117	found_player = 1;
118	break;
119	}
120	}
121	if(found_player == 0) return true;
122	else {
123	char message_buffer[512] = {0};
124	flatline_packet message;
125	int message_size;
126	data[datalen] = 0;
127
128	DDrConsole_PrintF("%s: %s", Players[i].name, packet->data);
129	sprintf(message_buffer, "%s: %s", Players[i].name, packet->data);
130
131	message.id = MESSAGE;
132	message_size = sprintf(message.data, "%s", message_buffer);
133	COrMessage_Print(message_buffer, "chat", 0);
134	UDPServer_SendToAll(&message, message_size + 1 + FLATLINE_HEADER);
135	break;
136	}
137	case CHANGE_NAME:
138	; //wtf, needed or i get an error.
139	// DDrConsole_PrintF("Changing Name to: %s", packet->data);
140	for(i = 0; i < MAX_PLAYERS; i++) {
141	if(PlayerList[i] && PlayerList[i]->ip == sender.sin_addr.S_un.S_addr) {
142	found_player = 1;
143	break;
144	}
145	}
146	if(found_player == 0) break;
147	else {
148	bool name_exists = 0;
149	for(j = 0; j < MAX_PLAYERS; j++) {
150	if(PlayerList[j] && !strcmp(packet->data, PlayerList[j]->name)) {
151	name_exists = 1;
152	break;
153	}
154	}
155	if(!name_exists) {
156	FLsUpdateName( i, packet->data );
157	}
158	break;
159	}
160	case PLAYER_INPUT:
161
162	for(i = 0; i < max_connections; i++) {
163	if(PlayerList[i] != 0 && PlayerList[i]->ip == sender.sin_addr.S_un.S_addr) {
164	found_player = 1;
165	break;
166	}
167	}
168
169	if(found_player == 0) break;
170	else {
171	input_struct * packet_input = &packet->input_struct;
172
173
174	PlayerList[i]->InputFromClient.Actions1 = packet_input->Actions1;
175	PlayerList[i]->InputFromClient.Actions2 = packet_input->Actions2;
176	PlayerList[i]->InputFromClient.MouseDeltaX = packet_input->MouseDeltaX;
177	PlayerList[i]->InputFromClient.MouseDeltaY = packet_input->MouseDeltaY;
178	PlayerList[i]->LastInputTime = packet_input->Time;
179
180	break;
181	}
182	case PK_PONG:
183	for(i = 0; i < max_connections; i++) {
184	if(PlayerList[i] != 0 && PlayerList[i]->ip == sender.sin_addr.S_un.S_addr) {
185	found_player = 1;
186	break;
187	}
188	}
189
190	if(found_player == 0) break;
191	if(packet->ping != lastPingTime)
192	{
193	PlayerList[i]->Ping = 999;
194	}
195	else
196	{
197	PlayerList[i]->Ping = GetTickCount() - packet->ping;
198	}
199	break;
200	default:
201	DDrConsole_PrintF("Warning, recieved badly formed packet!");
202	break;
203	}
204	return true;
205	}
206
207	bool FLrServer_Run()
208	{
209	// Get the local hostname
210	char szHostName[255];
211	struct hostent *host_entry;
212	gethostname(szHostName, 255);
213
214	host_entry=gethostbyname(szHostName);
215	DDrConsole_PrintF("Server started at %s...", inet_ntoa ((struct in_addr )*host_entry->h_addr_list));
216	return NetUDPServer_Listen(27777, FLrServer_PacketCallback);
217	}
218
219	short TRrAnimation_GetType(char* anim)
220	{
221	return (short)(anim + 0x15A);
222	}
223
224	void ONrCharacter_SetAnimationInternal(Character* Char, ActiveCharacter* AChar,
225	short inFromState, short inNextAnimType, const void *TRAM)
226	{
227	ONCC *ONCC = Char->ONCC;
228	void *TRAC = ONCC->TRAC;
229	short index = Char->Number;
230	short animType;
231
232	if (TRAM == 0) return;
233
234	animType = TRrAnimation_GetType(TRAM);
235
236	AChar->Animation = TRAM;
237	AChar->Frame = 0;
238	AChar->AnimationFromState = inFromState;
239	AChar->AnimationType = animType;
240
241	AChar->NextAnimationType= inNextAnimType;
242	AChar->AnimationToState = TRrAnimation_GetTo(TRAM);
243
244	return;
245	}
246
247
248
249
250
251
252	//wtf, this needs cleaned up...
253	player_info *FLr_FindEmptySlot() {
254	int j;
255	for(j = 0; j < MAX_PLAYERS; j++) {
256	if (Players[j].ip == 0) {
257	return &Players[j];
258	}
259	}
260	return 0;
261	}
262
263	extern uint16_t max_connections;
264	uint16_t FLr_FindEmptyListSlot() {
265	int j;
266	for(j = 0; j < max_connections; j++) {
267	if (PlayerList[j] == 0) {
268	return j;
269	}
270	}
271	return -1;
272	}
273	typedef struct
274	{
275	uint16_t x;
276	uint16_t y;
277
278	} IMtPoint2D;
279	static flatline_packet cache_input = {0};
280
281
282	void * ONICALL FLrInput_Update_Keys(void)
283	{
284	uint32_t i;
285	flatline_packet all_input = {0};
286	int16_t InputIndex = 0;
287
288	if(client_connected)
289	{
290	int sent_bytes;
291	flatline_packet input_packet = {0};
292
293	FLrClient_GetPackets();
294
295	input_packet.id = PLAYER_INPUT;
296	input_packet.input_struct.Time = ONgGameState->GameTime;
297	input_packet.input_struct.Actions1 = ((GameState*)(ONgGameState))->Input.Current.Actions1;
298	input_packet.input_struct.Actions2 = ((GameState*)(ONgGameState))->Input.Current.Actions2;
299	input_packet.input_struct.MouseDeltaX = ((GameState*)(ONgGameState))->Input.MouseDeltaX;
300	input_packet.input_struct.MouseDeltaY = ((GameState*)(ONgGameState))->Input.MouseDeltaY;
301
302	sent_bytes = NetUDPSocket_Send(client_sock,(sockaddr ) &address, (char)&input_packet, sizeof(input_struct) + FLATLINE_HEADER);
303
304	//return ONgGameState;
305	}
306
307
308	if(!(server_started \|\| client_connected)) return ONgGameState;
309
310
311	if(server_started)
312	{
313	if(ONgGameState->GameTime % 120 == 0)
314	{
315	FLsPingAll();
316	}
317
318	if(PlayerList[0])
319	{
320	PlayerList[0]->InputFromClient.Actions1 = ONgGameState->Input.Current.Actions1;
321	PlayerList[0]->InputFromClient.Actions2 = ONgGameState->Input.Current.Actions2;
322	PlayerList[0]->InputFromClient.MouseDeltaX = ONgGameState->Input.MouseDeltaX;
323	PlayerList[0]->InputFromClient.MouseDeltaY = ONgGameState->Input.MouseDeltaY;
324	}
325	FLsSendPlayerData();
326	}
327	for(i = 0; i < max_connections; i++) {
328	ActiveCharacter * Active_Player;
329	Character* Player;
330	GameInput * Active_Input;
331	if(PlayerList[i] == 0) continue;
332
333	Player = PlayerList[i]->Chr;
334	Active_Player = ONrGetActiveCharacter( PlayerList[i]->Chr);
335
336	if(!Player)
337	{
338	DDrConsole_Print("Warning, missing Character!");
339	continue;
340	}
341
342
343
344	//Set the health properly first.
345	if( client_connected && DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Health) )
346	{
347	PlayerList[i]->Chr->MaxHealth = PlayerList[i]->Health.MaxHealth;
348	ONrCharacter_SetHitPoints( PlayerList[i]->Chr, PlayerList[i]->Health.Health);
349	PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_Health );
350	}
351	//If the player is dead
352	if( PlayerList[i]->Chr->Health == 0 )
353
354	{
355	const short TicksToRespawn = 3 * 60;
356
357	//Permanently kill off dumb AI
358	if(PlayerList[i]->flags & PF_SCRIPTEDAI)
359	{
360	FLrPlayerDisconnect( i );
361	continue;
362	}
363
364	//Just to know if we have started counting off the respawn
365	if(PlayerList[i]->state != STATE_DEAD)
366	{
367	PlayerList[i]->state = STATE_DEAD;
368	PlayerList[i]->DeathTime = ONgGameState->GameTime;
369	if(i == client_slot)
370	{
371	ONrGameState_Timer_Start( "", TicksToRespawn );
372	}
373
374	if(server_started)
375	{
376	FLsPublic_Event( EV_KILLED, &i );
377	}
378
379	}
380
381	//Server respawning
382	if(server_started)
383	{
384	int Actions;
385	if(i == 0)
386	{
387	Actions = ONgGameState->Input.Current.Actions1;
388	}
389	else
390	{
391	Actions = PlayerList[i]->InputFromClient.Actions1;
392	}
393
394	if(ONgGameState->GameTime - PlayerList[i]->DeathTime > TicksToRespawn &&
395	(Actions & (Action_Punch \| Action_Kick)) )
396	{
397	FLrPlayerRespawn( i );
398
399	FLsPublic_Event( EV_RESPAWN, &i );
400	}
401	else
402	{
403	continue;
404	}
405	}
406	else //clients?!
407	{
408	continue;
409	}
410	}
411
412	PlayerList[i]->state = STATE_ALIVE;
413
414	if( DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Facing ) )
415	{
416	PlayerList[i]->Chr->Facing = PlayerList[i]->Facings.Facing;
417	PlayerList[i]->Chr->DesiredFacing = PlayerList[i]->Facings.DesiredFacing;
418	PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_Facing );
419	}
420
421	if(Active_Player == 0) continue;
422
423	if( client_connected && DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Position) )
424	{
425	Active_Player->PhyContext->Position = PlayerList[i]->Position;
426
427	PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_Position );
428	}
429
430
431
432
433	if (!(Player->Flags & ONcCharacterFlag_BeingThrown) &&
434	DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Animation) && (PlayerList[i]->Animation))
435	{
436	// get a pointer to the animation
437
438
439	if (PlayerList[i]->Animation != Active_Player->Animation)
440	{
441
442	///////////////////////////////////
443	//TODO: Check age of animation
444	///////////////////////////////////
445
446	// set the characters animation
447	/*ONrCharacter_SetAnimationInternal(Player,
448	Active_Player,
449	Active_Player->AnimationToState,
450	0,
451	Animation);*/
452	//ONrCharacter_NewAnimationHook(Player, Active_Player);
453	ONrCharacter_SetAnimationExternal(Player, TRrAnimation_GetFrom(PlayerList[i]->Animation), PlayerList[i]->Animation, 0);
454	//ONrCharacter_NewAnimationHook(Player, Active_Player);
455	}
456
457
458	}
459	PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_Animation );
460
461	//Don't update the frame if we are waiting to change the animation
462	if(DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_FramePing) && PlayerList[i]->Frame != -1
463	//&& !DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Animation)
464	)
465	{
466	if( abs(PlayerList[i]->Frame - Active_Player->Frame) > 2 )
467	{
468	short AnimationLength;
469	AnimationLength = TRrAnimation_GetDuration(Active_Player->Animation);
470	if (PlayerList[i]->Frame >= AnimationLength)
471	{
472	Active_Player->Frame = AnimationLength - 1;
473	//Active_Player->Frame = 0;
474	}
475	else
476	{
477	Active_Player->Frame = PlayerList[i]->Frame;
478	}
479	}
480	PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_FramePing );
481	}
482
483	//Increment frame in case we were waiting
484	PlayerList[i]->Frame++;
485
486	if (DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Throws)
487	&& PlayerList[i]->ThrowData.throwName[0] != 0)
488	{
489	if(PlayerList[PlayerList[i]->ThrowData.throwing])
490	{
491	short throwTarget = PlayerList[PlayerList[i]->ThrowData.throwing]->spawnnumber;
492	if ((throwTarget != Active_Player->throwing) &&
493	(PlayerList[i]->ThrowData.throwFrame < 10))
494	{
495	void *throw_animation;
496	ActiveCharacter* Target;
497	// get the animation
498
499	TMrInstance_GetDataPtr(
500	'TRAM',
501	PlayerList[i]->ThrowData.throwName,
502	&throw_animation);
503	//if (error) return;
504
505	// set the throw target
506	Active_Player->ThrowTargetCharacter = &ONgGameState->CharacterStorage[throwTarget];
507	Target = ONrGetActiveCharacter(Active_Player->ThrowTargetCharacter);
508	if ((Target->Animation != throw_animation) &&
509	// (OldAnimation != Animation) &&
510	!(Active_Player->ThrowTargetCharacter->Flags & ONcCharacterFlag_BeingThrown))
511	{
512	// set the throw variables
513	Active_Player->targetThrow = throw_animation;
514	Active_Player->throwing = throwTarget;
515
516	// run the throw
517	ONrCharacter_NewAnimationHook(Player, Active_Player);
518
519	if (Active_Player->ThrowTargetCharacter)
520	{
521	Target->Frame += 2;
522	Target->thrownBy = Player->Number;
523	}
524	}
525	}
526	}
527	else
528	{
529	DDrConsole_PrintF("Warning, tried to throw nonexistant player %hi",
530	PlayerList[i]->ThrowData.throwing );
531	}
532	}
533
534	//Always discard old throw data, even if it isnt applied
535	PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_Throws );
536
537	//Active_Player->PlayingFilm.Flags = 1;
538	Active_Input = &(Active_Player->Input);
539
540	if( (server_started && i !=0) \|\| !server_started )
541	{
542	Active_Input->Stop.Actions1 = ~PlayerList[i]->Input.Actions1 & Active_Input->Current.Actions1;
543	Active_Input->Stop.Actions2 = ~PlayerList[i]->Input.Actions2 & Active_Input->Current.Actions2;
544	Active_Input->Start.Actions1 = ~Active_Input->Current.Actions1 & PlayerList[i]->Input.Actions1;
545	Active_Input->Start.Actions2 = ~Active_Input->Current.Actions2 & PlayerList[i]->Input.Actions2;
546
547	Active_Input->Current.Actions1 = PlayerList[i]->Input.Actions1;
548	Active_Input->Current.Actions2 = PlayerList[i]->Input.Actions2;
549	Active_Input->Stopped.Actions1 = ~Active_Input->Current.Actions1;
550	Active_Input->Stopped.Actions2 = ~Active_Input->Current.Actions2;
551	Active_Input->MouseDeltaX = PlayerList[i]->Input.MouseDeltaX;
552	Active_Input->MouseDeltaY = PlayerList[i]->Input.MouseDeltaY;
553	}
554
555	//Check for character switching requests
556	if(server_started && PlayerList[i]->Chr->Health != 0 && PlayerList[i]->InputFromClient.Actions1 & Action_Block && PlayerList[i]->ShapeshiftCooldown < ONgGameState->GameTime)
557	{
558	int error;
559
560
561
562	ONCC *newClass;
563	short numClasses = (short)TMrInstance_GetTagCount('ONCC');
564	/*
565	if(Active_Player->Input.Start.Actions1 & Action_Block)
566	{
567	//This might not be getting hit. Find out why, eh?
568	PlayerList[i]->ShapeshiftCooldown = ONgGameState->GameTime + 15;
569	}
570	else
571	{
572	PlayerList[i]->ShapeshiftCooldown = ONgGameState->GameTime + 5;
573	}
574	*/
575	if (PlayerList[i]->InputFromClient.Actions1 & Action_Crouch) {
576	Player->ONCCnumber += numClasses - 1;
577	}
578	else {
579	Player->ONCCnumber += 1;
580	}
581
582	if (numClasses > 0) {
583	Player->ONCCnumber = Player->ONCCnumber % numClasses;
584
585	error = TMrInstance_GetDataPtr_ByNumber('ONCC', Player->ONCCnumber, &newClass);
586
587	if ((newClass != NULL) && (!error)) {
588	ONrCharacter_SetCharacterClass(Player, newClass);
589	}
590	}
591
592	}
593
594
595	}
596
597	MultiplayerStatus.PleaseUpdateAllPlayers = 0;
598	return ONgGameState;
599	}
600
601	void FLrPlayerDisconnect( int Player )
602	{
603	if(server_started)
604	{
605	//FLsPublic_Event(EV_DISCONNECT, &Player );
606	MultiplayerStatus.PleaseUpdateAllPlayers = 1;
607	}
608	//Kill off the character in another function, please
609	//ONrCharacter_SetHitPoints( PlayerList[Player]->Chr, 0);
610
611	memset(PlayerList[Player], 0, sizeof(player_info));
612	PlayerList[Player] = 0;
613
614
615
616	return;
617	}
618
619	void FLrPlayerRespawn( int Player )
620	{
621	PlayerList[Player]->state = STATE_ALIVE;
622	ONrCorpse_Create(PlayerList[Player]->Chr);
623	ONrCharacter_SetHitPoints( PlayerList[Player]->Chr, PlayerList[Player]->Chr->MaxHealth );
624	}
625
626
627	void* ScoreboardInstance = 0;
628	void FLrRun_Scores()
629	{
630	if(client_connected \|\| server_started)
631	{
632	if(!ScoreboardInstance){
633	void* TSFFTahoma;
634	TMrInstance_GetDataPtr( 'TSFF', "Tahoma", &TSFFTahoma);
635	TSrContext_New( TSFFTahoma, 7, 1, 1, 0, &ScoreboardInstance);
636	}
637	if(ScoreboardInstance){
638	const int white = 0x00FFFFFF;
639	const int green = 0x0000FF00;
640	const int red = 0x00FF0000;
641	int i;
642	char DrawString[255];
643	const int LineHeight = 15;
644	IMtPoint2D DrawLocation = {20, 20};
645	TSrContext_SetShade(ScoreboardInstance, white);
646	TSrContext_DrawText(ScoreboardInstance, "Oni Flatline build " __DATE__ " " __TIME__, 255, 0, &DrawLocation);
647	DrawLocation.y += LineHeight;
648	TSrContext_DrawText(ScoreboardInstance, "Name", 255, 0, &DrawLocation);
649	DrawLocation.x += 150;
650	TSrContext_DrawText(ScoreboardInstance, "Score", 255, 0, &DrawLocation);
651	DrawLocation.x += 50;
652	TSrContext_DrawText(ScoreboardInstance, "Ping", 255, 0, &DrawLocation);
653	for(i = 0; i <MAX_PLAYERS; i++)
654	{
655	if(PlayerList[i] == 0 \|\| PlayerList[i]->Chr == 0) continue;
656
657	DrawLocation.x = 20;
658	DrawLocation.y += LineHeight;
659
660	if(PlayerList[i]->Chr && PlayerList[i]->Chr->Health == 0)
661	{
662	TSrContext_SetShade(ScoreboardInstance, red);
663	}
664	else if (i == client_slot)
665	{
666	TSrContext_SetShade(ScoreboardInstance, green);
667	}
668	TSrContext_DrawText(ScoreboardInstance, PlayerList[i]->name, 255, 0, &DrawLocation);
669	TSrContext_SetShade(ScoreboardInstance, white);
670	DrawLocation.x += 150;
671	sprintf(DrawString, "%i", PlayerList[i]->Chr->Damage);
672	TSrContext_DrawText(ScoreboardInstance, DrawString, 255, 0, &DrawLocation);
673	DrawLocation.x += 50;
674	sprintf(DrawString, "%i", PlayerList[i]->Ping);
675	TSrContext_DrawText(ScoreboardInstance, DrawString, 255, 0, &DrawLocation);
676	}
677	}
678	}
679	}
680
681	bool FlatlineInitialize()
682	{
683
684	memset( Players, 0, sizeof( player_info ) * MAX_PLAYERS );
685	memset( PlayerList, 0, 4 * MAX_PLAYERS );
686	memset( &MultiplayerStatus, 0, sizeof( multiplayer_status ));
687	return 1;
688	}