C++ InPacket::readbyte方法代码示例

	void DropItemHandler::handle(InPacket& recv) const
	{
		int8_t mode = recv.readbyte();
		int32_t oid = recv.readint();
		bool meso = recv.readbool();
		int32_t itemid = recv.readint();
		int32_t owner = recv.readint();
		int8_t pickuptype = recv.readbyte();
		Point<int16_t> dropto = recv.readpoint();

		recv.skip(4);

		Point<int16_t> dropfrom;
		if (mode != 2)
		{
			dropfrom = recv.readpoint();

			recv.skip(2);
		}
		else
		{
			dropfrom = dropto;
		}

		if (!meso)
		{
			recv.skip(8);
		}
		bool playerdrop = !recv.readbool();

		Stage::get().getdrops().adddrop(oid, itemid, meso, owner, dropfrom, dropto, pickuptype, mode, playerdrop);
	}

	void Login::parseworlds(InPacket& recv)
	{
		int8_t worldid = recv.readbyte();
		if (worldid != -1)
		{
			World world;
			world.wid = worldid;
			world.name = recv.readascii();
			world.flag = recv.readbyte();
			world.message = recv.readascii();

			recv.skip(5);

			world.channelcount = recv.readbyte();
			for (uint8_t i = 0; i < world.channelcount; i++)
			{
				recv.readascii();
				recv.skip(4);
				world.chloads.push_back(recv.readbyte());
				recv.skip(2);
			}

			worlds.push_back(world);
		}
	}

	LookEntry Login::parselook(InPacket& recv) const
	{
		LookEntry look;

		look.female = recv.readbool();
		look.skin = recv.readbyte();
		look.faceid = recv.readint();
		recv.readbool(); //megaphone
		look.hairid = recv.readint();
		uint8_t slot = recv.readbyte();
		while (slot != 0xFF)
		{
			look.equips[slot] = recv.readint();
			slot = recv.readbyte();
		}
		slot = recv.readbyte();
		while (slot != 0xFF)
		{
			look.maskedequips[slot] = recv.readint();
			slot = recv.readbyte();
		}
		look.maskedequips[-111] = recv.readint();
		for (uint8_t i = 0; i < 3; i++)
		{
			look.petids.push_back(recv.readint());
		}

		return look;
	}

	void Login::parsecharlist(InPacket& recv)
	{
		size_t numchars = recv.readbyte();
		for (size_t i = 0; i < numchars; i++)
		{
			addcharentry(recv);
		}

		account.pic = recv.readbyte();
		account.slots = static_cast<int8_t>(recv.readint());
	}

	void SkillMacrosHandler::handle(InPacket& recv) const
	{
		uint8_t size = recv.readbyte();
		for (uint8_t i = 0; i < size; i++)
		{
			recv.readascii(); // name
			recv.readbyte(); // 'shout' byte
			recv.readint(); // skill 1
			recv.readint(); // skill 2
			recv.readint(); // skill 3
		}
	}

	void ServerIPHandler::handle(InPacket& recv) const
	{
		recv.skip(2);

		// Read the ipv4 adress in a string.
		string addrstr;
		for (int i = 0; i < 4; i++)
		{
			uint8_t num = static_cast<uint8_t>(recv.readbyte());
			addrstr.append(std::to_string(num));
			if (i < 3)
			{
				addrstr.push_back('.');
			}
		}

		// Read the port adress in a string.
		string portstr = std::to_string(recv.readshort());

		int32_t cid = recv.readint();

		// Attempt to reconnect to the server and if successfull, login to the game.
		Session::get().reconnect(addrstr.c_str(), portstr.c_str());
		PlayerLoginPacket(cid).dispatch();
	}

	Account::Account(InPacket& recv)
	{
		recv.readshort();
		accid = recv.readint();
		female = recv.readbool();
		recv.readbool(); //is admin
		gmlevel = recv.readbyte();
		recv.readbyte();
		name = recv.readascii();
		recv.readbyte();
		muted = recv.readbool();
		recv.readlong(); //muted until
		recv.readlong(); //creation date
		recv.readint();
		pin = recv.readshort();
		selected = 0;
	}

	void Login::parseaccount(InPacket& recv)
	{
		recv.readshort();
		account.accid = recv.readint();
		account.female = recv.readbool();
		recv.readbool(); //is admin
		account.gmlevel = recv.readbyte();
		recv.readbyte();
		account.name = recv.readascii();
		recv.readbyte();
		account.muted = recv.readbool();
		recv.readlong(); //muted until
		recv.readlong(); //creation date
		recv.readint();
		account.pin = recv.readshort();
		account.selected = 0;
	}

	void Login::parseworld(InPacket& recv)
	{
		uint8_t worldid = static_cast<uint8_t>(recv.readbyte());
		if (worldid != 255)
		{
			World toadd = World(worldid, recv);
			worlds.push_back(toadd);
		}
	}

	Footholdtree::Footholdtree(InPacket& recv)
	{
		int16_t leftw = 30000;
		int16_t rightw = -30000;
		int16_t botb = -30000;
		int16_t topb = 30000;

		uint16_t numbase = recv.readshort();
		for (uint16_t i = 0; i < numbase; i++)
		{
			uint8_t layer = recv.readbyte();
			uint16_t nummid = recv.readshort();
			for (uint16_t j = 0; j < nummid; j++)
			{
				uint16_t numlast = recv.readshort();
				for (uint16_t k = 0; k < numlast; k++)
				{
					Foothold foothold = Foothold(recv, layer);

					if (foothold.getl() < leftw)
					{
						leftw = foothold.getl();
					}
					else if (foothold.getr() > rightw)
					{
						rightw = foothold.getr();
					}

					if (foothold.getb() > botb)
					{
						botb = foothold.getb();
					}
					else if (foothold.gett() < topb)
					{
						topb = foothold.gett();
					}

					uint16_t id = foothold.getid();
					footholds[id] = foothold;

					if (abs(foothold.getslope()) < 0.5)
					{
						int16_t start = foothold.getl();
						int16_t end = foothold.getr();
						for (int16_t i = start; i <= end; i++)
						{
							footholdsbyx.insert(std::make_pair(i, id));
						}
					}
				}
			}
		}

		walls = Range<int16_t>(leftw + 25, rightw - 25);
		borders = Range<int16_t>(topb - 400, botb + 400);
	}

	StatsEntry Login::parsestats(InPacket& recv) const
	{
		StatsEntry statsentry;

		statsentry.name = recv.readpadascii(13);

		recv.readbool(); //gender
		recv.readbyte(); //skin
		recv.readint(); //face
		recv.readint(); //hair

		for (size_t i = 0; i < 3; i++)
		{
			statsentry.petids.push_back(recv.readlong());
		}

		statsentry.stats[Maplestat::LEVEL] = recv.readbyte();
		statsentry.stats[Maplestat::JOB] = recv.readshort();
		statsentry.stats[Maplestat::STR] = recv.readshort();
		statsentry.stats[Maplestat::DEX] = recv.readshort();
		statsentry.stats[Maplestat::INT] = recv.readshort();
		statsentry.stats[Maplestat::LUK] = recv.readshort();
		statsentry.stats[Maplestat::HP] = recv.readshort();
		statsentry.stats[Maplestat::MAXHP] = recv.readshort();
		statsentry.stats[Maplestat::MP] = recv.readshort();
		statsentry.stats[Maplestat::MAXMP] = recv.readshort();
		statsentry.stats[Maplestat::AP] = recv.readshort();
		statsentry.stats[Maplestat::SP] = recv.readshort();
		statsentry.exp = recv.readint();
		statsentry.stats[Maplestat::FAME] = recv.readshort();

		recv.skip(4); //gachaexp
		statsentry.mapid = recv.readint();
		statsentry.portal = recv.readbyte();
		recv.skip(4); //timestamp

		statsentry.job = CharJob(statsentry.stats[Maplestat::JOB]);

		return statsentry;
	}

	Background::Background(InPacket& recv)
	{
		node backsrc = nl::nx::map["Back"];
		animation = backsrc[recv.read<string>()];
		opacity = recv.readshort();
		flipped = recv.readbool();
		cx = recv.readshort();
		cy = recv.readshort();
		rx = recv.readshort();
		ry = recv.readshort();
		moveobj.setx(recv.readshort());
		moveobj.sety(recv.readshort());

		Type type = typebyid(recv.readbyte());
		settype(type);
	}

	void AttackHandler::handle(InPacket& recv) const
	{
		int32_t cid = recv.readint();
		uint8_t count = recv.readbyte();

		recv.skip(1);

		using Gameplay::AttackResult;
		AttackResult attack;
		attack.type = type;

		attack.level = recv.readbyte();
		attack.skill = (attack.level > 0) ? recv.readint() : 0;

		attack.display = recv.readbyte();
		attack.toleft = recv.readbool();
		attack.stance = recv.readbyte();
		attack.speed = recv.readbyte();

		recv.skip(1);

		attack.bullet = recv.readint();

		attack.mobcount = (count >> 4) & 0xF;
		attack.hitcount = count & 0xF;
		for (uint8_t i = 0; i < attack.mobcount; i++)
		{
			int32_t oid = recv.readint();

			recv.skip(1);

			using Gameplay::Skill;
			uint8_t length = (attack.skill == Skill::MESO_EXPLOSION) ? recv.readbyte() : attack.hitcount;
			for (uint8_t j = 0; j < length; j++)
			{
				int32_t damage = recv.readint();
				bool critical = false; // todo
				auto singledamage = std::make_pair(damage, critical);
				attack.damagelines[oid].push_back(singledamage);
			}
		}

		using Gameplay::Stage;
		Stage::get().showattack(cid, attack);
	}

	World::World(uint8_t id, InPacket& recv)
	{
		wid = id;
		name = recv.readascii();
		flag = recv.readbyte();
		message = recv.readascii();
		recv.readbyte();
		recv.readbyte();
		recv.readbyte();
		recv.readbyte();
		recv.readbyte();
		channelcount = recv.readbyte();
		for (uint8_t i = 0; i < channelcount; i++)
		{
			recv.readascii();
			recv.readint();
			chloads.push_back(recv.readbyte());
			recv.readshort();
		}
	}

	Movement MovementHandler::parsemovement(InPacket& recv) const
	{
		Movement fragment;

		fragment.command = recv.readbyte();
		switch (fragment.command)
		{
		case 0:
		case 5:
		case 17:
			fragment.type = Movement::_ABSOLUTE;
			fragment.xpos = recv.readshort();
			fragment.ypos = recv.readshort();
			fragment.lastx = recv.readshort();
			fragment.lasty = recv.readshort();
			recv.skip(2);
			fragment.newstate = recv.readbyte();
			fragment.duration = recv.readshort();
			break;
		case 1:
		case 2:
		case 6:
		case 12:
		case 13:
		case 16:
			fragment.type = Movement::_RELATIVE;
			fragment.xpos = recv.readshort();
			fragment.ypos = recv.readshort();
			fragment.newstate = recv.readbyte();
			fragment.duration = recv.readshort();
			break;
		case 11:
			fragment.type = Movement::CHAIR;
			fragment.xpos = recv.readshort();
			fragment.ypos = recv.readshort();
			recv.skip(2);
			fragment.newstate = recv.readbyte();
			fragment.duration = recv.readshort();
			break;
		case 15:
			fragment.type = Movement::JUMPDOWN;
			fragment.xpos = recv.readshort();
			fragment.ypos = recv.readshort();
			fragment.lastx = recv.readshort();
			fragment.lasty = recv.readshort();
			recv.skip(2);
			fragment.fh = recv.readshort();
			fragment.newstate = recv.readbyte();
			fragment.duration = recv.readshort();
			break;
		case 3:
		case 4:
		case 7:
		case 8:
		case 9:
		case 14:
			fragment.type = Movement::NONE;
			break;
		case 10:
			fragment.type = Movement::NONE;
			//change equip
			break;
		}

		return fragment;
	}