c++ AddU64 error

0

mam problem z kompilacją używając AddU64(unsigned long long) wywala error i nie wiem co jest zle

kod:

 	if (player->getPlayerInfo(PLAYERINFO_LEVEL) > 65535)
	{
		msg.AddU32(player->getPlayerInfo(PLAYERINFO_LEVEL));
		msg.AddU16(0);
	}
	else if (player->getExperience() > 10446744073709551615LLU)
	{
		msg.AddU32(0);
		msg.AddU16(player->getPlayerInfo(PLAYERINFO_LEVEL));
	}
	else
	{
		msg.AddU64((unsigned long long)player->getExperience());
		msg.AddU16(player->getPlayerInfo(PLAYERINFO_LEVEL));
	}

errory:

 In member function `virtual void Protocol76::AddPlayerStats(NetworkMessage&, const Player*)': 
class NetworkMessage' has no member named 'AddU64' 
1

No kompilator dosyć jasno i wyraźnie mówi, że nie ma takiej metody.

0
twonek napisał(a):

No kompilator dosyć jasno i wyraźnie mówi, że nie ma takiej metody.

jak ją mogę dodać? próbowałem tak

 void NetworkMessage::AddU64(unsigned long long value)

ale nie działa pomożesz trochę?

0

sprawdz w H sprawdz w CPP zobacz jak deklaracja i definicja jest zdefiniowana. Popatrz czy sa takie same i czy przekazywany typ (ktory przekazujesz) zgadza sie z deklaracja/definicja

1

A ta klasa NetworkMessage to Twoja jest? Jak nie to nie, nie możesz "dodać". Zobacz sobie (w kodzie, dokumentacji) jakie metody udostępnia ta klasa.

0
fasadin napisał(a):

sprawdz w H sprawdz w CPP zobacz jak deklaracja i definicja jest zdefiniowana. Popatrz czy sa takie same i czy przekazywany typ (ktory przekazujesz) zgadza sie z deklaracja/definicja

mam tylko definijcie zrobione do AddU32/GetU32
kod wygląda tak:


#include <string>
#include <iostream>
#include <sstream>

#include "networkmessage.h"

#include "item.h"
#include "container.h"
#include "creature.h"
#include "player.h"

#include "position.h"



/******************************************************************************/

NetworkMessage::NetworkMessage()
{
  Reset();
}

NetworkMessage::~NetworkMessage()
{
}


/******************************************************************************/

void NetworkMessage::Reset()
{
  m_MsgSize = 0;
  m_ReadPos = 2;  
}


/******************************************************************************/

bool NetworkMessage::ReadFromSocket(SOCKET socket)
{
	// just read the size to avoid reading 2 messages at once
	m_MsgSize = recv(socket, (char*)m_MsgBuf, 2, 0);
	
	// for now we expect 2 bytes at once, it should not be splitted
	int datasize = m_MsgBuf[0] | m_MsgBuf[1] << 8;
	if((m_MsgSize != 2) || (datasize > NETWORKMESSAGE_MAXSIZE-2)){
		int errnum;
#if defined WIN32 || defined __WINDOWS__
		errnum = ::WSAGetLastError();
		if(errnum == EWOULDBLOCK){
			m_MsgSize = 0;
			return true;
		}
#else
		errnum = errno;
#endif

		Reset();
		return false;
	}

	// read the real data
	m_MsgSize += recv(socket, (char*)m_MsgBuf+2, datasize, 0);

	// we got something unexpected/incomplete
	if ((m_MsgSize <= 2) || ((m_MsgBuf[0] | m_MsgBuf[1] << 8) != m_MsgSize-2))
	{
		Reset();
		return false;
	}

	// ok, ...reading starts after the size
	m_ReadPos = 2;

	return true;
}


bool NetworkMessage::WriteToSocket(SOCKET socket)
{
	if (m_MsgSize == 0)
		return true;

	m_MsgBuf[0] = (unsigned char)(m_MsgSize);
	m_MsgBuf[1] = (unsigned char)(m_MsgSize >> 8);
  
	bool ret = true;
	int sendBytes = 0;
	int flags;

#if defined WIN32 || defined __WINDOWS__
	// Set the socket I/O mode; iMode = 0 for blocking; iMode != 0 for non-blocking
	unsigned long mode = 1;
	ioctlsocket(socket, FIONBIO, &mode);
	flags = 0;
#else
	flags = MSG_DONTWAIT;
#endif
	int retry = 0;
  	do{
    	int b = send(socket, (char*)m_MsgBuf+sendBytes, std::min(m_MsgSize-sendBytes+2, 1000), flags);
		if(b <= 0){
#if defined WIN32 || defined __WINDOWS__
			int errnum = ::WSAGetLastError();
			if(errnum == EWOULDBLOCK){
				b = 0;
				OTSYS_SLEEP(10);
				retry++;
				if(retry == 10){
					ret = false;
					break;
				}
			}
			else
#endif
			{
				ret = false;
				break;
			}
		}
    	sendBytes += b;
	}while(sendBytes < m_MsgSize+2);

#if defined WIN32 || defined __WINDOWS__
	mode = 0;
	ioctlsocket(socket, FIONBIO, &mode);
#endif

  return ret;
}


/******************************************************************************/


unsigned char NetworkMessage::GetByte()
{
  return m_MsgBuf[m_ReadPos++];
}


unsigned short NetworkMessage::GetU16()
{
  unsigned short v = ((m_MsgBuf[m_ReadPos]) | (m_MsgBuf[m_ReadPos+1] << 8));
  m_ReadPos += 2;
  return v;
}

unsigned short NetworkMessage::GetItemId()
{
	unsigned short v = this->GetU16();
	return (unsigned short)Item::items.reverseLookUp(v);
}

unsigned int NetworkMessage::GetU32()
{
  unsigned int v = ((m_MsgBuf[m_ReadPos  ]      ) | (m_MsgBuf[m_ReadPos+1] <<  8) |
                    (m_MsgBuf[m_ReadPos+2] << 16) | (m_MsgBuf[m_ReadPos+3] << 24));
  m_ReadPos += 4;
  return v;
}


std::string NetworkMessage::GetString()
{
  int stringlen = GetU16();
  if (stringlen >= (16384 - m_ReadPos))
	  return std::string();

  char* v = (char*)(m_MsgBuf+m_ReadPos);
  m_ReadPos += stringlen;
  return std::string(v, stringlen);
}

std::string NetworkMessage::GetRaw(){
  int stringlen = m_MsgSize- m_ReadPos;
  if (stringlen >= (16384 - m_ReadPos))
	  return std::string();

  char* v = (char*)(m_MsgBuf+m_ReadPos);
  m_ReadPos += stringlen;
  return std::string(v, stringlen);
}

Position NetworkMessage::GetPosition() {
  Position pos;
  pos.x = GetU16();
  pos.y = GetU16();
  pos.z = GetByte();
  return pos;
}


void NetworkMessage::SkipBytes(int count)
{
  m_ReadPos += count;
}


/******************************************************************************/


void NetworkMessage::AddByte(unsigned char value)
{
  if(!canAdd(1))
    return;
  m_MsgBuf[m_ReadPos++] = value;
  m_MsgSize++;
}


void NetworkMessage::AddU16(unsigned short value)
{
  if(!canAdd(2))
    return;
  m_MsgBuf[m_ReadPos++] = (unsigned char)(value);
  m_MsgBuf[m_ReadPos++] = (unsigned char)(value >> 8);
  m_MsgSize += 2;
}

void NetworkMessage::AddU32(unsigned int value)
{
  if(!canAdd(4))
    return;
  m_MsgBuf[m_ReadPos++] = (unsigned char)(value);
  m_MsgBuf[m_ReadPos++] = (unsigned char)(value >>  8);
  m_MsgBuf[m_ReadPos++] = (unsigned char)(value >> 16);
  m_MsgBuf[m_ReadPos++] = (unsigned char)(value >> 24);
  m_MsgSize += 4;
}

void NetworkMessage::AddString(const std::string &value)
{
  AddString(value.c_str());
}


void NetworkMessage::AddString(const char* value)
{
  unsigned long stringlen = (unsigned long) strlen(value);
  if(!canAdd(stringlen+2) || stringlen > 8192)
    return;
  AddU16((unsigned short)stringlen);
  strcpy((char*)m_MsgBuf + m_ReadPos, value);
  m_ReadPos += stringlen;
  m_MsgSize += stringlen;
}


/******************************************************************************/


void NetworkMessage::AddPosition(const Position &pos)
{
  AddU16(pos.x);
  AddU16(pos.y);
  AddByte(pos.z);
}


void NetworkMessage::AddItem(unsigned short id, unsigned char count)
{
	const ItemType &it = Item::items[id];

	AddU16(it.clientId);

	if(it.stackable || it.isSplash() || it.isFluidContainer())
		AddByte(count);
}

void NetworkMessage::AddItem(const Item *item)
{
	const ItemType &it = Item::items[item->getID()];

	AddU16(it.clientId);

	if(it.stackable || it.isSplash() || it.isFluidContainer())
    AddByte((unsigned char)item->getItemCountOrSubtype());
}

void NetworkMessage::AddItemId(const Item *item)
{
	const ItemType &it = Item::items[item->getID()];

	AddU16(it.clientId);
}

void NetworkMessage::JoinMessages(NetworkMessage &add){
	if(!canAdd(add.m_MsgSize))
      return;
	memcpy(&m_MsgBuf[m_ReadPos],&(add.m_MsgBuf[2]),add.m_MsgSize);
	m_ReadPos += add.m_MsgSize;
  	m_MsgSize += add.m_MsgSize;
}
 
1

Google sugeruje, że masz starą/złą wersję: https://github.com/opentibia/server/blob/master/src/networkmessage.cpp

0
twonek napisał(a):

Google sugeruje, że masz starą/złą wersję: https://github.com/opentibia/server/blob/master/src/networkmessage.cpp

dzięki ale jak zmienie to mi się czasem nie zepsuję reszta kodu?

2

Raczej bym się zastanowił, dlaczego kod klienta korzysta z funkcji, której nie ma. Może oczekuje innej wersji niż ta, którą mu dostarczono.

0
twonek napisał(a):

Raczej bym się zastanowił, dlaczego kod klienta korzysta z funkcji, której nie ma. Może oczekuje innej wersji niż ta, którą mu dostarczono.

po stronie klienta jest GetU64 więc wymagane jest po stronie silnika AddU64

0
twonek napisał(a):

Raczej bym się zastanowił, dlaczego kod klienta korzysta z funkcji, której nie ma. Może oczekuje innej wersji niż ta, którą mu dostarczono.

uint64_t zmieniłem na unsigned long long działa!
wielkie dzięki można temat zamknąć i jeszcze raz dzięki!!!
teraz juz wiem jak mogę zrobić definicje czy jak to się nazywa :P

1 użytkowników online, w tym zalogowanych: 0, gości: 1