コード例 #1
0
ファイル: Dan.cpp プロジェクト: gthgame/gth
void CDanBattleFunc::RecvCC_SuggestResult()
{
	if ( !IsGuildMasters( g_curPC ) )		
		return;

	
	LPREQUEST_RECORD pSuggest=g_pDanBattleManager->GetSuggester();
	LPREQUEST_RECORD pRequest=static_cast<LPREQUEST_RECORD>(g_pDanBattleManager->GetRequestPointer(NULL));

	if ( pSuggest == NULL )
		return ;

	if ( pSuggest->ServerID >= MAX_PCS || pSuggest->ServerID < 0)
		return;

	
	
	if ( g_pc[pSuggest->ServerID].curChargeSE < g_logic.DanBattlePrice)
	{
		GTH_SendMessage_ChattingMsg(&g_pc[pSuggest->ServerID], 0, 0, 36 );
		SendGSM_SuggestResult(0);
		return;
	}

	
	BYTE bCommand = MSG_ReadByte();	
	SendGSM_SuggestResult(bCommand);
	if ( bCommand <= 0)
		return;




	

	if (pSuggest==NULL)
	{
		SendErrorCode(&g_curPC->sock,GSC_DAN_BATTLE,1,0);		
		return;
	}

	if (strcmp(pSuggest->DanName,g_curPC->guildName))
	{
		SendErrorCode(&g_curPC->sock,GSC_DAN_BATTLE,1,0);		
		return;
	}
	if (strcmp(pSuggest->MasterName,g_curPC->name))
	{
		SendErrorCode(&g_curPC->sock,GSC_DAN_BATTLE,1,0);		
		return;
	}
	
	
	
	g_pDanBattleManager->MakeBattleDan();

	
	
}
コード例 #2
0
ファイル: Dan.cpp プロジェクト: gthgame/gth
void CDanBattleFunc::SendGSM_SuggestResult(BYTE isallow)
{
	
	LPREQUEST_RECORD pSuggest=g_pDanBattleManager->GetSuggester();		
	LPREQUEST_RECORD pRequest=static_cast<LPREQUEST_RECORD>(g_pDanBattleManager->GetRequestPointer(NULL));

	if ( pRequest->ServerID >= MAX_PCS || pRequest->ServerID < 0)
		return;

	if (pSuggest==NULL)
	{
		SendErrorCode(&g_pc[pRequest->ServerID].sock,GSC_DAN_BATTLE,1,0);		
		return;
	}	
	
	MSG_BeginWriting(&netMessage);
	MSG_Clear( &netMessage );
		
	MSG_WriteByte(&netMessage, GSC_EXTEND);
	MSG_WriteByte(&netMessage, GSC_DAN_BATTLE);
	MSG_WriteByte(&netMessage, DANB_SUGGEST_RESULT);
	MSG_WriteByte(&netMessage, isallow);

	NET_SendUnreliableMessage(&g_pc[pRequest->ServerID].sock, &netMessage);

	MSG_EndWriting(&netMessage);

}
コード例 #3
0
ファイル: Dan.cpp プロジェクト: gthgame/gth
void CDanBattleFunc::RecvCC_ChangeBattleMap()
{
	if (g_pDanBattleManager->GetStatus()!=DBTL_STATUS_MOVE)
	{
		SendErrorCode(&g_curPC->sock,GSC_DAN_BATTLE,1,0);		
		return;
	}

	

	
}
コード例 #4
0
ファイル: Dan.cpp プロジェクト: gthgame/gth
void CDanBattleFunc::RecvGSM_RequestBattle()
{
	if ( g_pDanBattleManager->GetStatus() != DBTL_STATUS_READY )
	{										
		entityPCList_t reqPl;
		char userName[NAMESTRING];

		sstrncpy( userName, MSG_ReadString(), NAMESTRING - 1 );

		if( g_entityListMng.FindPCList( userName, &reqPl ) == -1 )
			return;

		SendErrorCode(&g_memberServer[reqPl.serverIdx].sock,GMS_DAN_BATTLE,1,0);
		return;
	}
}
コード例 #5
0
ファイル: Dan.cpp プロジェクト: gthgame/gth
void CDanBattleFunc::RecvCC_CancelRequest()
{
	if ( !IsGuildMasters( g_curPC ) )		
		return;

	REQUEST_RECORD	canRecord;

	canRecord.No		= 0;
	canRecord.ServerNo	= g_config.gameServerNo;
	canRecord.ServerID	= g_curPC->idx;
	canRecord.DanIdx	= g_curPC->guildIdx;
	memcpy(canRecord.DanName,g_curPC->guildName,GUILDNAMESTRING);
	memcpy(canRecord.MasterName,g_curPC->name,NAMESTRING);
		

	if ( !g_pDanBattleManager->DeleteRequester(&canRecord))			
	{
		SendErrorCode(&g_curPC->sock,GSC_DAN_BATTLE,1,0);
		return;
	}	

	
	g_pDanBattleManager->BroadCast_RequesterList();
}
コード例 #6
0
ファイル: ble_process.c プロジェクト: Ahamedjee/PSoC-4-BLE
/*******************************************************************************
* Function Name: GenericEventHandler
********************************************************************************
* Summary:
*        Event handler function for the BLE stack. All the events by BLE stack
* are received by application through this function. For this, CyBle_ProcessEvents()
* should be called continuously in main loop.
*
* Parameters:
*  event: 		event value
*  eventParame: pointer to the location where relevant event data is stored
*
* Return:
*  void
*
*******************************************************************************/
void GenericEventHandler(uint32 event, void * eventParam)
{
	/* Local variables and data structures*/
	CYBLE_GATTS_WRITE_REQ_PARAM_T 		writeReqData;
	CYBLE_GATTC_WRITE_REQ_T				writeADVcounterdata;
	CYBLE_GAPC_ADV_REPORT_T				scan_report;
	CYBLE_GATTS_WRITE_CMD_REQ_PARAM_T	writeCmdData;
	CYBLE_API_RESULT_T					apiResult;
	CYBLE_GATTC_WRITE_REQ_T 			writeRGBdata;
	
	switch(event)
	{
		case CYBLE_EVT_STACK_ON:
			#ifdef DEBUG_ENABLED
			UART_UartPutString("CYBLE_EVT_STACK_ON ");
			UART_UartPutCRLF(' ');
			#endif
			/* At the start of the BLE stack, start advertisement */
			CyBle_GappStartAdvertisement(CYBLE_ADVERTISING_FAST);
		break;
			
		case CYBLE_EVT_GAPP_ADVERTISEMENT_START_STOP:
			/* This event is received at every start or stop of peripheral advertisement*/
			#ifdef DEBUG_ENABLED
			UART_UartPutString("CYBLE_EVT_GAPP_ADVERTISEMENT_START_STOP ");
			SendBLEStatetoUART(CyBle_GetState());
			UART_UartPutCRLF(' ');
			#endif
			
			if((CYBLE_STATE_DISCONNECTED == CyBle_GetState()) && (switch_Role == FALSE))
			{
				/* If the current state of the BLE is Disconnected, then restart advertisement.
				* Note that the advertisement should only be restarted if the switch flag is not
				* TRUE. If switch role flag is TRUE, then there is no need to start advertisement
				* as the GAP role has to be switched*/
				CyBle_GappStartAdvertisement(CYBLE_ADVERTISING_FAST);	
				
				if(apiResult == CYBLE_ERROR_OK)
				{
					#ifdef DEBUG_ENABLED
					UART_UartPutString("Restart Advertisement ");
					SendBLEStatetoUART(CyBle_GetState());
					UART_UartPutCRLF(' ');
					#endif
				}
			}
		break;
			
		case CYBLE_EVT_GAPC_SCAN_START_STOP:
			/* This event is received at every start or stop of central scanning*/
			#ifdef DEBUG_ENABLED
			UART_UartPutString("CYBLE_EVT_GAPC_SCAN_START_STOP ");
			SendBLEStatetoUART(CyBle_GetState());
			UART_UartPutCRLF(' ');
			#endif
		break;
			
		case CYBLE_EVT_GATT_CONNECT_IND:
			/* This event is received at GATT connection with a device. This event
			* is received for both Client or Server role */
			#ifdef DEBUG_ENABLED
			UART_UartPutString("CYBLE_EVT_GATT_CONNECT_IND ");
			UART_UartPutCRLF(' ');
			#endif
		break;
		
		case CYBLE_EVT_GATT_DISCONNECT_IND:
			/* This event is received at GATT disconnection with a device. This event
			* is received for both Client or Server role */
			#ifdef DEBUG_ENABLED
			UART_UartPutString("CYBLE_EVT_GATT_DISCONNECT_IND ");
			UART_UartPutCRLF(' ');
			#endif
		break;
			
		case CYBLE_EVT_GATTS_WRITE_REQ:
			/* This event is received at when Server receives a Write request from
			* connected Client device */
			/* Save the associated event parameter in local variable */
			writeReqData = *(CYBLE_GATTS_WRITE_REQ_PARAM_T*)eventParam;

			if(writeReqData.handleValPair.attrHandle == CYBLE_RGB_LED_CONTROL_CHAR_HANDLE)
			{
				/* If the Write request is on RGB LED Control Characteristic, then Client is 
				* trying to set a new color to the device. */
				if(writeReqData.handleValPair.value.len == RGB_LED_DATA_LEN)
				{
					#ifdef DEBUG_ENABLED
						UART_UartPutString("RGB CYBLE_EVT_GATTS_WRITE_REQ ");
						UART_UartPutCRLF(' ');
					#endif
					
					/* Extract the four bytes containing the color value and store it */
					RGBData[RGB_RED_INDEX] = writeReqData.handleValPair.value.val[0];
					RGBData[RGB_GREEN_INDEX] = writeReqData.handleValPair.value.val[1];
					RGBData[RGB_BLUE_INDEX] = writeReqData.handleValPair.value.val[2];
					RGBData[RGB_INTENSITY_INDEX] = writeReqData.handleValPair.value.val[3];
					
					/* Modify RGB Color my configuring the PrISM components with new density 
					* value*/
					UpdateRGBled(RGBData, RGB_LED_DATA_LEN);
					
					/* Update the RGB LED Control characteristic in GATT DB  to allow
					* Client to read the latest RGB LED color value set */
					CyBle_GattsWriteAttributeValue(&writeReqData.handleValPair,0,&cyBle_connHandle,CYBLE_GATT_DB_LOCALLY_INITIATED);
							
					#ifdef ENABLE_ADV_DATA_COUNTER
					/* Increment the ADV data counter so that scanning Central device knows
					* if this device has updated RGB LED data or not */
					dataADVCounter++;
					#endif
					
					#ifdef DEBUG_ENABLED
					UART_UartPutString("incremented dataADVCounter value in CYBLE_EVT_GATTS_WRITE_REQ= ");
					PrintNum(dataADVCounter);
					UART_UartPutCRLF(' ');
					#endif
					
					/* After receiveing the color value, set the switch role flag to allow the system
					* to switch role to Central role */
					switch_Role = TRUE;
					
					#ifdef DEBUG_ENABLED
					UART_UartPutString("switchRole to Central");
					UART_UartPutCRLF(' ');
					#endif
				}
				else
				{
					/* Send the error code for invalid attribute length packet */
					SendErrorCode(CYBLE_GATT_WRITE_REQ, 
									writeReqData.handleValPair.attrHandle, 
									ERR_INVALID_ATT_LEN);
					
					return;
				}
			}

			/* As part of every write request, the server needs to send a write response. Note
			* that this will be sent only if all the application layer conditions are met on a 
			* write request. Else, an appropriate error code is sent. */
	        CyBle_GattsWriteRsp(cyBle_connHandle);
		break;
			
		case CYBLE_EVT_GATTS_WRITE_CMD_REQ:
			/* This event is generated whenever a Client device sends a Write Command (Write 
			* without response) to a connected Server. Save the associated event parameter in
			* local variable. */
			writeCmdData = *(CYBLE_GATTS_WRITE_CMD_REQ_PARAM_T*)eventParam;
			
			/* Check if the Write command is for ADV Data counter characteristic */
			if(writeCmdData.handleValPair.attrHandle == CYBLE_RGB_DATA_COUNT_CHAR_HANDLE)
			{
				/* If the data sent is of one byte, then proceed. */
				if(writeCmdData.handleValPair.value.len == 1)
				{
					/* Extract and save the set ADV data counter value */
					dataADVCounter = *(writeCmdData.handleValPair.value.val);	
					
					/* This increment is done to balance the ++ done as part of CYBLE_EVT_GATTS_WRITE_REQ */
					dataADVCounter--;
					
					/* Update the ADV data counter characteristic in GATT DB  to allow
					* Client to read the latest ADV data counter value */
					CyBle_GattsWriteAttributeValue(&writeCmdData.handleValPair,
													0,
													&cyBle_connHandle,
													CYBLE_GATT_DB_LOCALLY_INITIATED);

					#ifdef DEBUG_ENABLED
					UART_UartPutString("dataADVCounter from CYBLE_EVT_GATTS_WRITE_CMD_REQ = ");
					PrintNum(dataADVCounter);
					UART_UartPutCRLF(' ');
					#endif
				}	/* if(writeCmdData.handleValPair.value.len == 1) */
			}
			break;
		
		case CYBLE_EVT_GAPC_SCAN_PROGRESS_RESULT:
			/* This event is generated whenever there is a peripheral device found by 
			* while scanning */
			if(CYBLE_STATE_CONNECTED != CyBle_GetState())	
			{
				/* If we are not connected to any peripheral device, then save the new device  
				* information so to add it to our list */
				scan_report = *(CYBLE_GAPC_ADV_REPORT_T*)eventParam;
				
				#ifdef DEBUG_ENABLED
					UART_UartPutString("CYBLE_EVT_GAPC_SCAN_PROGRESS_RESULT ");
					UART_UartPutCRLF(' ');
				#endif
				
				#ifdef ENABLE_ADV_DATA_COUNTER
				/* If ADV DATA COUNTER is enabled, then the central device would check
				* if the counter in ADV packet of peripheral is less than its own counter
				* or not. If yes, then it will consider the peripheral as a potential 
				* device to connect to.*/
				if(scan_report.eventType == CYBLE_GAPC_CONN_UNDIRECTED_ADV)
				{
					/* If the scan report received is of advertising nature and the data 
					* length is as expected... */
					if(scan_report.dataLen == new_advData.advDataLen)
					{
						/* If the second last value of the advertising data matches the custom 
						* marker, then the peripheral is a node of the network */
						if(scan_report.data[scan_report.dataLen-2] == CUSTOM_ADV_DATA_MARKER)
						{
							/* If the ADV counter data in Advertising data is less than that of
							* the value in this scanning device, then the node is a potential node 
							* whose color has to be updated. */
							if((scan_report.data[scan_report.dataLen-1] < dataADVCounter) ||
							((scan_report.data[scan_report.dataLen-1] == 255) && (dataADVCounter == 0)))
							{
								/* Potential node found*/
								potential_node_found = TRUE;
								/* Save the advertising peripheral address and type*/
								memcpy(potential_node_bdAddr, scan_report.peerBdAddr, 6);
								potential_node_bdAddrType = scan_report.peerAddrType;
								
								#ifdef DEBUG_ENABLED
								UART_UartPutString("potential_node_found ");
								UART_UartPutCRLF(' ');
								#endif
							}
							else
							{
								/* If the ADV data counter is equal or more than the data counter
								* in this scanning device, then the node has latest RGB LED data
								* and does not need to be connected to. Reset the potential node 
								* address */
								potential_node_found = FALSE;
								
								potential_node_bdAddrType = 0;
								
								potential_node_bdAddr[0] = 0x00;
								potential_node_bdAddr[1] = 0x00;
								potential_node_bdAddr[2] = 0x00;
								potential_node_bdAddr[3] = 0x00;
								potential_node_bdAddr[4] = 0x00;
								potential_node_bdAddr[5] = 0x00;
							}
						}
					}
				}
				#endif
				
				/* If the received scan data is part of scan response from a peripheral... */
				if(scan_report.eventType == CYBLE_GAPC_SCAN_RSP)
				{
					/* If the data lenght of the scan reponse packet is equal to expected
					* scan response data lenght...*/
					if(scan_report.dataLen == SCAN_TAG_DATA_LEN)
					{
						#ifdef ENABLE_ADV_DATA_COUNTER
						/* If a potential node had been found earlier as part of received 
						* advertising data, then compare the address of stored potential 
						* node and received address of the scan response */
						if(potential_node_found)
						{
							/* Compare the two addresses and type */
							if((!memcmp(scan_report.peerBdAddr, potential_node_bdAddr, 6))  
								&& (potential_node_bdAddrType == scan_report.peerAddrType))
							{
						#endif
								/* If the scan report data matches the expected data (scan_tag),
								* then it is our desired node */
								if(!memcmp(scan_report.data, scan_tag, scan_report.dataLen))
								{
									#ifdef DEBUG_ENABLED
									UART_UartPutString("Titan Found ");
									UART_UartPutCRLF(' ');
									#endif
									/* Stop existing scan */
									CyBle_GapcStopScan();
									#ifdef DEBUG_ENABLED
									UART_UartPutString("Stop Scan called ");
									UART_UartPutCRLF(' ');
									#endif
									
									/* Save the peripheral BD address and type*/
									peripAddr.type = scan_report.peerAddrType;
									peripAddr.bdAddr[0] = scan_report.peerBdAddr[0];
									peripAddr.bdAddr[1] = scan_report.peerBdAddr[1];
									peripAddr.bdAddr[2] = scan_report.peerBdAddr[2];
									peripAddr.bdAddr[3] = scan_report.peerBdAddr[3];
									peripAddr.bdAddr[4] = scan_report.peerBdAddr[4];
									peripAddr.bdAddr[5] = scan_report.peerBdAddr[5];

									/* Set the flag to allow application to connect to the
									* peripheral found */
									clientConnectToDevice = TRUE;
									
									#ifdef ENABLE_ADV_DATA_COUNTER
									/* Reset the potential node flag*/
									potential_node_found = FALSE;
									#endif
								}
						#ifdef ENABLE_ADV_DATA_COUNTER
							}
						}
						#endif
					}
				}
			}

		break;
			
		case CYBLE_EVT_GAP_DEVICE_CONNECTED:
			/* This event is received whenever the device connect on GAP layer */
			if(ble_gap_state == BLE_CENTRAL)
			{
				#ifdef ENABLE_CENTRAL_DISCOVERY
					/* The Device is connected now. Start Attributes discovery process.*/
					CyBle_GattcStartDiscovery(cyBle_connHandle);
					#ifdef DEBUG_ENABLED
						UART_UartPutString("CYBLE_EVT_GAP_DEVICE_CONNECTED ");
						SendBLEStatetoUART(CyBle_GetState());
						UART_UartPutCRLF(' ');
					#endif
				#else
					/* If this system is currently acting in Central role and has connected
					* to a peripheral device, then write directly the ADV counter data and
					* RGB LED control data using attribute handles */
					
					/* Set the device connected flag */
					deviceConnected = TRUE;
					
					#ifdef DEBUG_ENABLED
						UART_UartPutString("Directly write RGB using Attr handle ");
						SendBLEStatetoUART(CyBle_GetState());
						UART_UartPutCRLF(' ');
					#endif
					
					/* Write the Data Counter value */
					writeADVcounterdata.attrHandle = CYBLE_RGB_DATA_COUNT_CHAR_HANDLE;
					writeADVcounterdata.value.val = &dataADVCounter;
					writeADVcounterdata.value.len = 1;
					CyBle_GattcWriteWithoutResponse(cyBle_connHandle, &writeADVcounterdata);
				
					/* Write the RGB LED Value */
					writeRGBdata.attrHandle = CYBLE_RGB_LED_CONTROL_CHAR_HANDLE;
					writeRGBdata.value.val = RGBData;
					writeRGBdata.value.len = RGB_LED_DATA_LEN;
					CyBle_GattcWriteCharacteristicValue(cyBle_connHandle, &writeRGBdata);
				#endif
			}	
        break;
			
		case CYBLE_EVT_GATTC_DISCOVERY_COMPLETE:
			/* This event is generated whenever the discovery procedure is complete*/
			
			#ifdef ENABLE_CENTRAL_DISCOVERY
			deviceConnected = TRUE;
			#ifdef DEBUG_ENABLED
				UART_UartPutString("CYBLE_EVT_GATTC_DISCOVERY_COMPLETE ");
				SendBLEStatetoUART(CyBle_GetState());
				UART_UartPutCRLF(' ');
			#endif
			
			/* Write the Data Counter value */
			writeADVcounterdata.attrHandle = CYBLE_RGB_DATA_COUNT_CHAR_HANDLE;
			writeADVcounterdata.value.val = &dataADVCounter;
			writeADVcounterdata.value.len = 1;
			CyBle_GattcWriteWithoutResponse(cyBle_connHandle, &writeADVcounterdata);
		
			/* Write the RGB LED Value */
			writeRGBdata.attrHandle = CYBLE_RGB_LED_CONTROL_CHAR_HANDLE;
			writeRGBdata.value.val = RGBData;
			writeRGBdata.value.len = RGB_LED_DATA_LEN;
			CyBle_GattcWriteCharacteristicValue(cyBle_connHandle, &writeRGBdata);
			#endif
		break;
			
		case CYBLE_EVT_GATTC_WRITE_RSP:
			/* This event is generated when the Client device receives a response
			* as part of the Write request sent earlier. This indicates that
			* the RGB LED data was written successfully */
			#ifdef DEBUG_ENABLED
				UART_UartPutString("CYBLE_EVT_GATTC_WRITE_RSP ");
				SendBLEStatetoUART(CyBle_GetState());
				UART_UartPutCRLF(' ');
			#endif
			
			/* Disconnect the existing connection and restart scanning */
			if((cyBle_connHandle.bdHandle != 0))
			{
				CyBle_GapDisconnect(cyBle_connHandle.bdHandle);
				
				restartScanning = TRUE;
				#ifdef DEBUG_ENABLED
				UART_UartPutString("Disconnect from CYBLE_EVT_GATTC_WRITE_RSP ");
				SendBLEStatetoUART(CyBle_GetState());
				UART_UartPutCRLF(' ');
				#endif
			}
		break;

		case CYBLE_EVT_GAP_DEVICE_DISCONNECTED:
			/* This event is generated when the device disconnects from an 
			* existing connection */
			deviceConnected = FALSE;
			
			#ifdef DEBUG_ENABLED
				UART_UartPutString("CYBLE_EVT_GAP_DEVICE_DISCONNECTED ");
				SendBLEStatetoUART(CyBle_GetState());
				UART_UartPutCRLF(' ');
			#endif
			
			if((ble_gap_state == BLE_PERIPHERAL) && (switch_Role != TRUE))
			{
				/* If the current role of this system was Peripheral and the role
				* is not to be switched, then restart advertisement */
				if(CYBLE_STATE_DISCONNECTED == CyBle_GetState())
				{
					CyBle_GappStartAdvertisement(CYBLE_ADVERTISING_FAST);	
					#ifdef DEBUG_ENABLED
					UART_UartPutString("Restart Advertisement ");
					SendBLEStatetoUART(CyBle_GetState());
					UART_UartPutCRLF(' ');
					#endif
				}
			}
			else if((ble_gap_state == BLE_CENTRAL) && (switch_Role != TRUE))
			{
				/* If the current role of this system was Central and the role
				* is not to be switched, then restart scanning */
				if(CYBLE_STATE_DISCONNECTED == CyBle_GetState())
				{
					CyBle_GapcStartScan(CYBLE_SCANNING_FAST);	
					#ifdef DEBUG_ENABLED
					UART_UartPutString("Restart Scanning ");
					SendBLEStatetoUART(CyBle_GetState());
					UART_UartPutCRLF(' ');
					#endif
				}	
			}
		break;
			
		default:
			eventParam = eventParam;
		break;
	}
}
コード例 #7
0
ファイル: Dan.cpp プロジェクト: gthgame/gth
void CDanBattleFunc::RecvCC_SuggestBattle()
{
	if ( !IsGuildMasters( g_curPC ) )		
		return;


	

	REQUEST_RECORD	reqRecord;
	REQUEST_RECORD	sugRecord;

	reqRecord.No		= 0;
	reqRecord.ServerNo	= g_config.gameServerNo;
	reqRecord.ServerID	= g_curPC->idx;
	reqRecord.DanIdx	= g_curPC->guildIdx;
	memcpy(reqRecord.DanName,g_curPC->guildName,GUILDNAMESTRING);
	memcpy(reqRecord.MasterName,g_curPC->name,NAMESTRING);
		

	if ( !g_pDanBattleManager->isSuggester(&reqRecord))			
	{
		SendErrorCode(&g_curPC->sock,GSC_DAN_BATTLE,1,0);		
		return;
	}

	
	
	if ( g_curPC->curChargeSE < g_logic.DanBattlePrice)
	{
		
		SendGSM_SuggestResult(2);
		return;
	}

	sugRecord.DanIdx=MSG_ReadLong();

	sstrncpy( sugRecord.DanName, MSG_ReadString(), GUILDNAMESTRING - 1 );	

	if ( !g_pDanBattleManager->SetSuggester(&sugRecord))
	{
		SendErrorCode(&g_curPC->sock,GSC_DAN_BATTLE,1,0);				
		return;
	}	

	LPREQUEST_RECORD pSuggest=g_pDanBattleManager->GetSuggester();

	MSG_BeginWriting(&netMessage);
	MSG_Clear( &netMessage );
		
	MSG_WriteByte(&netMessage, GSC_EXTEND);
	MSG_WriteByte(&netMessage, GSC_DAN_BATTLE);
	MSG_WriteByte(&netMessage, DANB_SUGGEST_BATTLE);

	
	LPREQUEST_RECORD pSugg=static_cast<LPREQUEST_RECORD>(g_pDanBattleManager->GetRequestPointer(&sugRecord));


	if ( pSuggest->ServerID >= MAX_PCS || pSuggest->ServerID <0)
		return;

	NET_SendUnreliableMessage(&g_pc[pSuggest->ServerID].sock, &netMessage);

	MSG_EndWriting(&netMessage);

}
コード例 #8
0
ファイル: Dan.cpp プロジェクト: gthgame/gth
int CDanBattleFunc::RecvCC_ReqeustBattle(playerCharacter_t* pc)
{	
	
	playerCharacter_t *pPc = NULL;
	if ( pc != NULL)
		 pPc = pc;
	else
	{
		if ( g_curPC != NULL)
			pPc = g_curPC;
	}
	if ( pPc == NULL )
		return 0;	


	
	if(NULL == g_pDanBattleManager) return 1;
	if( !g_config.isManager ) return 1;
	


	
	if ( !IsGuildMasters( pPc ) )			
	{
		
		GTH_SendMessage_ChattingMsg(pPc, 1, 9, 59 );
		return -1;							
	}
	
	if ( g_pDanBattleManager->m_bDanTestMode == FALSE )
	{
		if ( CountDanUser(pPc->guildIdx)<9 )	
			return -2;
	}

	if ( !g_config.isManager )				
	{
		SendGSM_RequestBattle();
		return 1;
	}

	if ( g_pDanBattleManager->GetStatus() != DBTL_STATUS_READY )	
	{										
		SendErrorCode(&pPc->sock,GSC_DAN_BATTLE,1,0);
		return -3;
	}

	REQUEST_RECORD	reqRecord;

	reqRecord.No		= 0;
	reqRecord.ServerNo	= g_config.gameServerNo;
	reqRecord.ServerID	= pPc->idx;
	reqRecord.DanIdx	= pPc->guildIdx;
	memcpy(reqRecord.DanName,pPc->guildName,GUILDNAMESTRING);
	memcpy(reqRecord.MasterName,pPc->name,NAMESTRING);

	if ( !g_pDanBattleManager->InsertRquester(&reqRecord) )
	{
		SendErrorCode(&pPc->sock,GSC_DAN_BATTLE,1,0);		
	}

	g_pDanBattleManager->BroadCast_RequesterList();
	
	return 1;
}