Daodan/src/Flatline.c

#include "Flatline.h"
#include "Oni_Character.h"
#include "Oni_Gamestate.h"
#include "Oni_Symbols.h"
#include "Flatline_Client.h"
#include "Flatline_Server.h"
#include "Flatline_Events.h"
#include "Daodan_Utility.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


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 = ONgGameState->Input.Current.Actions1;
                input_packet.input_struct.Actions2 = ONgGameState->Input.Current.Actions2;
                input_packet.input_struct.MouseDeltaX = ONgGameState->Input.MouseDeltaX;
                input_packet.input_struct.MouseDeltaY = ONgGameState->Input.MouseDeltaY;
                input_packet.input_struct.DesiredFacing = ONgGameState->PlayerCharacter->DesiredFacing;

                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;


        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;
                }

                if( server_started && i != 0 )
                {
                        PlayerList[i]->Chr->DesiredFacing = PlayerList[i]->FacingFromClient;
                }


                //Set the health properly first.
                //Always overridden by the server because of the chance of random damage and such
                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( client_connected && DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Class ) )
                {
                        if(PlayerList[i]->Class)
                        {
                                ONrCharacter_SetCharacterClass( PlayerList[i]->Chr, PlayerList[i]->Class );
                        }
                        PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_Class );
                }

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

                if(Active_Player == 0) continue;

                
                        //              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;
                        if(client_connected && i == client_slot)
                        {
                                Active_Input->MouseDeltaX = ONgGameState->Input.MouseDeltaX;
                                Active_Input->MouseDeltaY = ONgGameState->Input.MouseDeltaY;
                        }
                        else
                        {
                                Active_Input->MouseDeltaX = PlayerList[i]->Input.MouseDeltaX;
                                Active_Input->MouseDeltaY = PlayerList[i]->Input.MouseDeltaY;
                        }
                } 
                
                {
                void* ConsoleAnimation = 0; 
                TMrInstance_GetDataPtr( 'TRAM', "KONOKOwatch_idle", &ConsoleAnimation);

                if(!Active_Player->IsInAir && Active_Input->Current.Actions1 & (Action_Console | Action_PauseScreen) 
                        && !(PlayerList[i]->Chr->Flags & ONcCharacterFlag_BeingThrown)
                        && Active_Player->ThrowTargetCharacter != -1)
                {
                        if(ConsoleAnimation && ConsoleAnimation != Active_Player->Animation)
                        {
                                ONrCharacter_SetAnimationExternal(PlayerList[i]->Chr, Active_Player->AnimationFromState, ConsoleAnimation, 10);
                                Player->Flags |= 0x00200000;
                                Active_Player->ForcedAnimationFrames = -1;// TRrAnimation_GetDuration(ConsoleAnimation);
                        }
                }
                else if(Active_Input->Stopped.Actions1 & (Action_Console | Action_PauseScreen) )
                {
                        Active_Player->ForcedAnimationFrames = 0;
                }

                }

                //Check for character switching requests
                if(server_started && PlayerList[i]->Chr->Health != 0 
                        && PlayerList[i]->InputFromClient.Actions1 & Action_Block)
                {
                        if( 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;
                                }
                                */

                                PlayerList[i]->ShapeshiftCooldown = ONgGameState->GameTime + 15;

                                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);
                                        }
                                }

                        }
                }
                else
                {
                        PlayerList[i]->ShapeshiftCooldown = 0;
                }
                if(client_connected) {

                        if( DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Position) )
                        {
                                //Active_Player->PhyContext->Position = PlayerList[i]->Position;

                                Active_Player->PhyContext->Position.X = 
                                        (PlayerList[i]->Position.X + Active_Player->PhyContext->Position.X) / 2;

                                Active_Player->PhyContext->Position.Y = 
                                        (PlayerList[i]->Position.Y + Active_Player->PhyContext->Position.Y) / 2;

                                Active_Player->PhyContext->Position.Z = 
                                        (PlayerList[i]->Position.Z + Active_Player->PhyContext->Position.Z) / 2;

                                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,
                                        PlayerList[i]->Animation);*/
                                        //ONrCharacter_NewAnimationHook(Player, Active_Player);
                                        ONrCharacter_SetAnimationExternal(Player, TRrAnimation_GetFrom(PlayerList[i]->Animation), PlayerList[i]->Animation, 1);
                                        //ONrCharacter_NewAnimationHook(Player, Active_Player);
                                }


                        }
                        PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_Animation );

                        //Disabled Frame syncing for now. In most cases it won't be useful.
                        if(0 && 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))
                                                //      Target->thrownBy == -
                                                {
                                                        // 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;
                                                                //DDrConsole_PrintF("Thrown by player %hi", Player->Number );
                                                                //DDrStartupMessage("Thrown by player %hi", Player->Number );
                                                                Target->thrownBy = Player->Number & 0x00ff;
                                                        }
                                                }
                                        }
                                }
                                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 );
                }


        }
        
        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();
        }
        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;
                        const int blue =        0x000000FF;
                        int i;
                        char DrawString[255];
                        const int LineHeight = 15;
                        IMtPoint2D DrawLocation = {25, 20};
                        TSrContext_SetShade(ScoreboardInstance, white);
                        TSrContext_DrawText(ScoreboardInstance, "Oni Flatline build " __DATE__ " " __TIME__, 255, 0, &DrawLocation);
                        TSrContext_SetShade(ScoreboardInstance, white);
                        DrawLocation.y += LineHeight;
                        DrawLocation.x = 25;
                        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 = 10;
                                DrawLocation.y += LineHeight;

                                sprintf(DrawString, "%i.", i );
                                TSrContext_DrawText(ScoreboardInstance, DrawString, 255, 0, &DrawLocation);
                                DrawLocation.x += 15;

                                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:	876
Committed:	Sat Jun 1 20:29:59 2013 UTC (12 years, 4 months ago) by gumby
Content type:	text/x-csrc
File size:	16775 byte(s)
Log Message:	Daodan pass 1
#	Content
1	#include "Flatline.h"
2	#include "Oni_Character.h"
3	#include "Oni_Gamestate.h"
4	#include "Oni_Symbols.h"
5	#include "Flatline_Client.h"
6	#include "Flatline_Server.h"
7	#include "Flatline_Events.h"
8	#include "Daodan_Utility.h"
9	#include <Windows.h>
10	//#include <sys/time.h>
11	#include <time.h>
12	#include <float.h>
13	#define isnan(x) ((x) != (x))
14	uint32_t last1 = 0; uint32_t last2 = 0;
15	player_info Players[MAX_PLAYERS] = {{0}, {0}, {0}, {0}};
16	player_info * PlayerList[MAX_CONNECTIONS] = {0};
17	multiplayer_status MultiplayerStatus;
18	unsigned int lastPingTime;
19
20	const char * Rejection_Messages[][255] = {
21	{"Server is full"},
22	{"-2"},
23	{"-3"},
24	{"-4"},
25	{"-5"},
26	};
27
28	#define BETTER_SYNC
29
30
31
32
33	short TRrAnimation_GetType(char* anim)
34	{
35	return (short)(anim + 0x15A);
36	}
37
38	void ONrCharacter_SetAnimationInternal(Character* Char, ActiveCharacter* AChar,
39	short inFromState, short inNextAnimType, const void *TRAM)
40	{
41	ONCC *ONCC = Char->ONCC;
42	void *TRAC = ONCC->TRAC;
43	short index = Char->Number;
44	short animType;
45
46	if (TRAM == 0) return;
47
48	animType = TRrAnimation_GetType(TRAM);
49
50	AChar->Animation = TRAM;
51	AChar->Frame = 0;
52	AChar->AnimationFromState = inFromState;
53	AChar->AnimationType = animType;
54
55	AChar->NextAnimationType= inNextAnimType;
56	AChar->AnimationToState = TRrAnimation_GetTo(TRAM);
57
58	return;
59	}
60
61
62
63
64
65
66	//wtf, this needs cleaned up...
67	player_info *FLr_FindEmptySlot() {
68	int j;
69	for(j = 0; j < MAX_PLAYERS; j++) {
70	if (Players[j].ip == 0) {
71	return &Players[j];
72	}
73	}
74	return 0;
75	}
76
77	extern uint16_t max_connections;
78	uint16_t FLr_FindEmptyListSlot() {
79	int j;
80	for(j = 0; j < max_connections; j++) {
81	if (PlayerList[j] == 0) {
82	return j;
83	}
84	}
85	return -1;
86	}
87	typedef struct
88	{
89	uint16_t x;
90	uint16_t y;
91	} IMtPoint2D;
92	static flatline_packet cache_input = {0};
93
94
95	void * ONICALL FLrInput_Update_Keys(void)
96	{
97	uint32_t i;
98	flatline_packet all_input = {0};
99	int16_t InputIndex = 0;
100
101	if(client_connected)
102	{
103	int sent_bytes;
104	flatline_packet input_packet = {0};
105
106	FLrClient_GetPackets();
107
108	input_packet.id = PLAYER_INPUT;
109	// input_packet.input_struct.Time = ONgGameState->GameTime;
110	input_packet.input_struct.Actions1 = ONgGameState->Input.Current.Actions1;
111	input_packet.input_struct.Actions2 = ONgGameState->Input.Current.Actions2;
112	input_packet.input_struct.MouseDeltaX = ONgGameState->Input.MouseDeltaX;
113	input_packet.input_struct.MouseDeltaY = ONgGameState->Input.MouseDeltaY;
114	input_packet.input_struct.DesiredFacing = ONgGameState->PlayerCharacter->DesiredFacing;
115
116	sent_bytes = NetUDPSocket_Send(client_sock,(sockaddr ) &address, (char)&input_packet, sizeof(input_struct) + FLATLINE_HEADER);
117
118	//return ONgGameState;
119	}
120
121
122	if(!(server_started \|\| client_connected)) return ONgGameState;
123
124
125
126	for(i = 0; i < max_connections; i++) {
127	ActiveCharacter * Active_Player;
128	Character* Player;
129	GameInput * Active_Input;
130	if(PlayerList[i] == 0) continue;
131
132
133
134	Player = PlayerList[i]->Chr;
135	Active_Player = ONrGetActiveCharacter( PlayerList[i]->Chr);
136
137	if(!Player)
138	{
139	DDrConsole_Print("Warning, missing Character!");
140	continue;
141	}
142
143	if( server_started && i != 0 )
144	{
145	PlayerList[i]->Chr->DesiredFacing = PlayerList[i]->FacingFromClient;
146	}
147
148
149
150	//Set the health properly first.
151	//Always overridden by the server because of the chance of random damage and such
152	if( client_connected && DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Health) )
153	{
154	PlayerList[i]->Chr->MaxHealth = PlayerList[i]->Health.MaxHealth;
155	ONrCharacter_SetHitPoints( PlayerList[i]->Chr, PlayerList[i]->Health.Health);
156	//PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_Health );
157	}
158
159	//If the player is dead
160	if( PlayerList[i]->Chr->Health == 0 )
161
162	{
163	const short TicksToRespawn = 3 * 60;
164
165	//Permanently kill off dumb AI
166	if(PlayerList[i]->flags & PF_SCRIPTEDAI)
167	{
168	FLrPlayerDisconnect( i );
169	continue;
170	}
171
172	//Just to know if we have started counting off the respawn
173	if(PlayerList[i]->state != STATE_DEAD)
174	{
175	PlayerList[i]->state = STATE_DEAD;
176	PlayerList[i]->DeathTime = ONgGameState->GameTime;
177	if(i == client_slot)
178	{
179	ONrGameState_Timer_Start( "", TicksToRespawn );
180	}
181
182	if(server_started)
183	{
184	FLsPublic_Event( EV_KILLED, &i );
185	}
186
187	}
188
189	//Server respawning
190	if(server_started)
191	{
192	int Actions;
193	if(i == 0)
194	{
195	Actions = ONgGameState->Input.Current.Actions1;
196	}
197	else
198	{
199	Actions = PlayerList[i]->InputFromClient.Actions1;
200	}
201
202	if(ONgGameState->GameTime - PlayerList[i]->DeathTime > TicksToRespawn &&
203	(Actions & (Action_Punch \| Action_Kick)) )
204	{
205	FLrPlayerRespawn( i );
206
207	FLsPublic_Event( EV_RESPAWN, &i );
208	}
209	else
210	{
211	continue;
212	}
213	}
214	else //clients?!
215	{
216	continue;
217	}
218	}
219
220	PlayerList[i]->state = STATE_ALIVE;
221
222	if( client_connected && DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Class ) )
223	{
224	if(PlayerList[i]->Class)
225	{
226	ONrCharacter_SetCharacterClass( PlayerList[i]->Chr, PlayerList[i]->Class );
227	}
228	PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_Class );
229	}
230
231	if( client_connected && DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Facing ) )
232	{
233	PlayerList[i]->Chr->Facing = PlayerList[i]->Facings.Facing;
234	if(i != client_slot)
235	{
236	PlayerList[i]->Chr->DesiredFacing = PlayerList[i]->Facings.DesiredFacing;
237	}
238	PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_Facing );
239	}
240
241	if(Active_Player == 0) continue;
242
243
244
245	// Active_Player->PlayingFilm.Flags = 1;
246
247	Active_Input = &(Active_Player->Input);
248
249
250	if( (server_started && i !=0) \|\| !server_started )
251	{
252	Active_Input->Stop.Actions1 = ~PlayerList[i]->Input.Actions1 & Active_Input->Current.Actions1;
253	Active_Input->Stop.Actions2 = ~PlayerList[i]->Input.Actions2 & Active_Input->Current.Actions2;
254	Active_Input->Start.Actions1 = ~Active_Input->Current.Actions1 & PlayerList[i]->Input.Actions1;
255	Active_Input->Start.Actions2 = ~Active_Input->Current.Actions2 & PlayerList[i]->Input.Actions2;
256
257	Active_Input->Current.Actions1 = PlayerList[i]->Input.Actions1;
258	Active_Input->Current.Actions2 = PlayerList[i]->Input.Actions2;
259	Active_Input->Stopped.Actions1 = ~Active_Input->Current.Actions1;
260	Active_Input->Stopped.Actions2 = ~Active_Input->Current.Actions2;
261	if(client_connected && i == client_slot)
262	{
263	Active_Input->MouseDeltaX = ONgGameState->Input.MouseDeltaX;
264	Active_Input->MouseDeltaY = ONgGameState->Input.MouseDeltaY;
265	}
266	else
267	{
268	Active_Input->MouseDeltaX = PlayerList[i]->Input.MouseDeltaX;
269	Active_Input->MouseDeltaY = PlayerList[i]->Input.MouseDeltaY;
270	}
271	}
272
273	{
274	void* ConsoleAnimation = 0;
275	TMrInstance_GetDataPtr( 'TRAM', "KONOKOwatch_idle", &ConsoleAnimation);
276
277	if(!Active_Player->IsInAir && Active_Input->Current.Actions1 & (Action_Console \| Action_PauseScreen)
278	&& !(PlayerList[i]->Chr->Flags & ONcCharacterFlag_BeingThrown)
279	&& Active_Player->ThrowTargetCharacter != -1)
280	{
281	if(ConsoleAnimation && ConsoleAnimation != Active_Player->Animation)
282	{
283	ONrCharacter_SetAnimationExternal(PlayerList[i]->Chr, Active_Player->AnimationFromState, ConsoleAnimation, 10);
284	Player->Flags \|= 0x00200000;
285	Active_Player->ForcedAnimationFrames = -1;// TRrAnimation_GetDuration(ConsoleAnimation);
286	}
287	}
288	else if(Active_Input->Stopped.Actions1 & (Action_Console \| Action_PauseScreen) )
289	{
290	Active_Player->ForcedAnimationFrames = 0;
291	}
292
293	}
294
295	//Check for character switching requests
296	if(server_started && PlayerList[i]->Chr->Health != 0
297	&& PlayerList[i]->InputFromClient.Actions1 & Action_Block)
298	{
299	if( PlayerList[i]->ShapeshiftCooldown < ONgGameState->GameTime)
300	{
301	int error;
302
303
304
305	ONCC *newClass;
306	short numClasses = (short)TMrInstance_GetTagCount('ONCC');
307	/*
308	if(Active_Player->Input.Start.Actions1 & Action_Block)
309	{
310	//This might not be getting hit. Find out why, eh?
311	PlayerList[i]->ShapeshiftCooldown = ONgGameState->GameTime + 15;
312	}
313	else
314	{
315	PlayerList[i]->ShapeshiftCooldown = ONgGameState->GameTime + 5;
316	}
317	*/
318
319	PlayerList[i]->ShapeshiftCooldown = ONgGameState->GameTime + 15;
320
321	if (PlayerList[i]->InputFromClient.Actions1 & Action_Crouch) {
322	Player->ONCCnumber += numClasses - 1;
323	}
324	else {
325	Player->ONCCnumber += 1;
326	}
327
328	if (numClasses > 0) {
329	Player->ONCCnumber = Player->ONCCnumber % numClasses;
330
331	error = TMrInstance_GetDataPtr_ByNumber('ONCC', Player->ONCCnumber, &newClass);
332
333	if ((newClass != NULL) && (!error)) {
334	ONrCharacter_SetCharacterClass(Player, newClass);
335	}
336	}
337
338	}
339	}
340	else
341	{
342	PlayerList[i]->ShapeshiftCooldown = 0;
343	}
344	if(client_connected) {
345
346	if( DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Position) )
347	{
348	//Active_Player->PhyContext->Position = PlayerList[i]->Position;
349
350	Active_Player->PhyContext->Position.X =
351	(PlayerList[i]->Position.X + Active_Player->PhyContext->Position.X) / 2;
352
353	Active_Player->PhyContext->Position.Y =
354	(PlayerList[i]->Position.Y + Active_Player->PhyContext->Position.Y) / 2;
355
356	Active_Player->PhyContext->Position.Z =
357	(PlayerList[i]->Position.Z + Active_Player->PhyContext->Position.Z) / 2;
358
359	PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_Position );
360	}
361
362
363
364
365	if (!(Player->Flags & ONcCharacterFlag_BeingThrown) &&
366	DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Animation) && (PlayerList[i]->Animation))
367	{
368	// get a pointer to the animation
369
370
371	if (PlayerList[i]->Animation != Active_Player->Animation)
372	{
373
374	///////////////////////////////////
375	//TODO: Check age of animation
376	///////////////////////////////////
377	// set the characters animation
378	/*ONrCharacter_SetAnimationInternal(Player,
379	Active_Player,
380	Active_Player->AnimationToState,
381	0,
382	PlayerList[i]->Animation);*/
383	//ONrCharacter_NewAnimationHook(Player, Active_Player);
384	ONrCharacter_SetAnimationExternal(Player, TRrAnimation_GetFrom(PlayerList[i]->Animation), PlayerList[i]->Animation, 1);
385	//ONrCharacter_NewAnimationHook(Player, Active_Player);
386	}
387
388
389	}
390	PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_Animation );
391
392	//Disabled Frame syncing for now. In most cases it won't be useful.
393	if(0 && DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_FramePing) && PlayerList[i]->Frame != -1
394	//&& !DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Animation)
395	)
396	{
397	if( abs(PlayerList[i]->Frame - Active_Player->Frame) > 2 )
398	{
399	short AnimationLength;
400	AnimationLength = TRrAnimation_GetDuration(Active_Player->Animation);
401	if (PlayerList[i]->Frame >= AnimationLength)
402	{
403	Active_Player->Frame = AnimationLength - 1;
404	//Active_Player->Frame = 0;
405	}
406	else
407	{
408	Active_Player->Frame = PlayerList[i]->Frame;
409	}
410	}
411
412	}
413	PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_FramePing );
414
415	//Increment frame in case we were waiting
416	PlayerList[i]->Frame++;
417
418	if (DoWeUpdateThis( PlayerList[i]->UpdateFlags, PFlag_Throws)
419	&& PlayerList[i]->ThrowData.throwName[0] != 0)
420	{
421	if(PlayerList[PlayerList[i]->ThrowData.throwing])
422	{
423	short throwTarget = PlayerList[PlayerList[i]->ThrowData.throwing]->spawnnumber;
424	/*if ((throwTarget != Active_Player->throwing) &&
425	(PlayerList[i]->ThrowData.throwFrame < 10))*/
426	{
427	void *throw_animation;
428	ActiveCharacter* Target;
429	// get the animation
430
431	TMrInstance_GetDataPtr(
432	'TRAM',
433	PlayerList[i]->ThrowData.throwName,
434	&throw_animation);
435	//if (error) return;
436
437	// set the throw target
438	Active_Player->ThrowTargetCharacter = &ONgGameState->CharacterStorage[throwTarget];
439	Target = ONrGetActiveCharacter(Active_Player->ThrowTargetCharacter);
440	//if (/(Target->Animation != throw_animation) &&/
441	// (OldAnimation != Animation) &&
442	// !(Active_Player->ThrowTargetCharacter->Flags & ONcCharacterFlag_BeingThrown))
443	// Target->thrownBy == -
444	{
445	// set the throw variables
446	Active_Player->targetThrow = throw_animation;
447	Active_Player->throwing = throwTarget;
448
449	// run the throw
450	ONrCharacter_NewAnimationHook(Player, Active_Player);
451
452	//if (Active_Player->ThrowTargetCharacter)
453	{
454	// Target->Frame += 2;
455	//DDrConsole_PrintF("Thrown by player %hi", Player->Number );
456	//DDrStartupMessage("Thrown by player %hi", Player->Number );
457	Target->thrownBy = Player->Number & 0x00ff;
458	}
459	}
460	}
461	}
462	else
463	{
464	DDrConsole_PrintF("Warning, tried to throw nonexistant player %hi",
465	PlayerList[i]->ThrowData.throwing );
466	}
467	}
468
469	//Always discard old throw data, even if it isnt applied
470	PlayerList[i]->UpdateFlags &= ~( 1 << PFlag_Throws );
471	}
472
473
474	}
475
476	if(server_started)
477	{
478	if(ONgGameState->GameTime % 120 == 0)
479	{
480	FLsPingAll();
481	}
482
483	if(PlayerList[0])
484	{
485	PlayerList[0]->InputFromClient.Actions1 = ONgGameState->Input.Current.Actions1;
486	PlayerList[0]->InputFromClient.Actions2 = ONgGameState->Input.Current.Actions2;
487	PlayerList[0]->InputFromClient.MouseDeltaX = ONgGameState->Input.MouseDeltaX;
488	PlayerList[0]->InputFromClient.MouseDeltaY = ONgGameState->Input.MouseDeltaY;
489	}
490	FLsSendPlayerData();
491	}
492	MultiplayerStatus.PleaseUpdateAllPlayers = 0;
493	return ONgGameState;
494	}
495
496	void FLrPlayerDisconnect( int Player )
497	{
498	if(server_started)
499	{
500	//FLsPublic_Event(EV_DISCONNECT, &Player );
501	MultiplayerStatus.PleaseUpdateAllPlayers = 1;
502	}
503	//Kill off the character in another function, please
504	//ONrCharacter_SetHitPoints( PlayerList[Player]->Chr, 0);
505
506	memset(PlayerList[Player], 0, sizeof(player_info));
507	PlayerList[Player] = 0;
508
509
510
511	return;
512	}
513
514	void FLrPlayerRespawn( int Player )
515	{
516	PlayerList[Player]->state = STATE_ALIVE;
517	ONrCorpse_Create(PlayerList[Player]->Chr);
518	ONrCharacter_SetHitPoints( PlayerList[Player]->Chr, PlayerList[Player]->Chr->MaxHealth );
519	}
520
521
522	void* ScoreboardInstance = 0;
523	void FLrRun_Scores()
524	{
525	if(client_connected \|\| server_started)
526	{
527	if(!ScoreboardInstance){
528	void* TSFFTahoma;
529	TMrInstance_GetDataPtr( 'TSFF', "Tahoma", &TSFFTahoma);
530	TSrContext_New( TSFFTahoma, 7, 1, 1, 0, &ScoreboardInstance);
531	}
532	if(ScoreboardInstance){
533	const int white = 0x00FFFFFF;
534	const int green = 0x0000FF00;
535	const int red = 0x00FF0000;
536	const int blue = 0x000000FF;
537	int i;
538	char DrawString[255];
539	const int LineHeight = 15;
540	IMtPoint2D DrawLocation = {25, 20};
541	TSrContext_SetShade(ScoreboardInstance, white);
542	TSrContext_DrawText(ScoreboardInstance, "Oni Flatline build " __DATE__ " " __TIME__, 255, 0, &DrawLocation);
543	TSrContext_SetShade(ScoreboardInstance, white);
544	DrawLocation.y += LineHeight;
545	DrawLocation.x = 25;
546	TSrContext_DrawText(ScoreboardInstance, "Name", 255, 0, &DrawLocation);
547	DrawLocation.x += 150;
548	TSrContext_DrawText(ScoreboardInstance, "Score", 255, 0, &DrawLocation);
549	DrawLocation.x += 50;
550	TSrContext_DrawText(ScoreboardInstance, "Ping", 255, 0, &DrawLocation);
551	for(i = 0; i <MAX_PLAYERS; i++)
552	{
553	if(PlayerList[i] == 0 \|\| PlayerList[i]->Chr == 0) continue;
554
555	DrawLocation.x = 10;
556	DrawLocation.y += LineHeight;
557
558	sprintf(DrawString, "%i.", i );
559	TSrContext_DrawText(ScoreboardInstance, DrawString, 255, 0, &DrawLocation);
560	DrawLocation.x += 15;
561
562	if(PlayerList[i]->Chr && PlayerList[i]->Chr->Health == 0)
563	{
564	TSrContext_SetShade(ScoreboardInstance, red);
565	}
566	else if (i == client_slot)
567	{
568	TSrContext_SetShade(ScoreboardInstance, green);
569	}
570	TSrContext_DrawText(ScoreboardInstance, PlayerList[i]->name, 255, 0, &DrawLocation);
571	TSrContext_SetShade(ScoreboardInstance, white);
572	DrawLocation.x += 150;
573	sprintf(DrawString, "%i", PlayerList[i]->Chr->Damage);
574	TSrContext_DrawText(ScoreboardInstance, DrawString, 255, 0, &DrawLocation);
575	DrawLocation.x += 50;
576	sprintf(DrawString, "%i", PlayerList[i]->Ping);
577	TSrContext_DrawText(ScoreboardInstance, DrawString, 255, 0, &DrawLocation);
578	}
579	}
580	}
581	}
582
583	bool FlatlineInitialize()
584	{
585	memset( Players, 0, sizeof( player_info ) * MAX_PLAYERS );
586	memset( PlayerList, 0, 4 * MAX_PLAYERS );
587	memset( &MultiplayerStatus, 0, sizeof( multiplayer_status ));
588	return 1;
589	}