Spawning player entity without any API?

I would like to spawn a simple entity that has a name, and can have a custom skin. Like a fake player. I would like to do this without using CitizensAPI, NPCFactory, or any other API. How difficult would this be to achieve? I understand it has to do with packets, but honestly I haven't done much w/packets and don't know whether or not this is a difficult task.

Thanks!

 

Code:java

    //Only the player p will be able to see the fake player.
    //If you want everyone to see the player you have to loop through every
    //player and use spawnPlayer() on them
    //
    //Yaw/Pitch is the way the players head is turned.
    //A yaw of 0 or 360 represents the positive z direction.
    //A yaw of 180 represents the negative z direction.
    //A yaw of 90 represents the negative x direction.
    //A yaw of 270 represents the positive x direction.
    public void spawnPlayer(Player p, String name, float yaw, float pitch)
    {
        ProtocolManager manager = ProtocolLibrary.getProtocolManager();
        WrapperPlayServerNamedEntitySpawn spawned = new WrapperPlayServerNamedEntitySpawn();
 
        Random ra = new Random();
        spawned.setEntityID(ra.nextInt(Integer.MAX_VALUE)+300);
        spawned.setPosition(p.getLocation().toVector());
        spawned.setPlayerName(name);
        spawned.setPlayerUUID(UUID.randomUUID().toString());
 
        spawned.setYaw(yaw);
        spawned.setPitch(pitch);
 
        // Documentation:
        // [url]http://mc.kev009.com/Entities#Entity_Metadata_Format[/url]
        WrappedDataWatcher watcher = new WrappedDataWatcher();
        watcher.setObject(0, (byte) 0);
        watcher.setObject(1, (short) 300);
        watcher.setObject(8, (byte) 6);
        spawned.setMetadata(watcher);
 
        try {
            manager.sendServerPacket(p, spawned.getHandle());
        } catch (InvocationTargetException e) {}
    }

 

TheMrGong WrappedPlayerServerNamedEntitySpawn isn't appearing to be importable?

 

Trevor1134
ProtocolLib.

 

LordVakar I have it...

 

Whoops here you go put this in a package that has the method I gave you.

Class: WrapperPlayServerNamedEntitySpawn

Code:java

/*
*  PacketWrapper - Contains wrappers for each packet in Minecraft.
*  Copyright (C) 2012 Kristian S. Stangeland
*
*  This program is free software; you can redistribute it and/or modify it under the terms of the
*  GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of
*  the License, or (at your option) any later version.
*
*  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
*  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*  See the GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License along with this program;
*  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
*  02111-1307 USA
*/
 
package com.gong.main;
 
import org.bukkit.World;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.util.Vector;
 
import com.comphenix.protocol.PacketType;
import com.comphenix.protocol.ProtocolLibrary;
import com.comphenix.protocol.events.PacketContainer;
import com.comphenix.protocol.events.PacketEvent;
import com.comphenix.protocol.injector.PacketConstructor;
import com.comphenix.protocol.wrappers.WrappedDataWatcher;
import com.comphenix.protocol.wrappers.WrappedGameProfile;
import com.google.common.base.Preconditions;
 
public class WrapperPlayServerNamedEntitySpawn extends AbstractPacket {
    public static final PacketType TYPE = PacketType.Play.Server.NAMED_ENTITY_SPAWN;
 
    // For constructing packets from entities
    private static PacketConstructor entityConstructor;
 
    public WrapperPlayServerNamedEntitySpawn() {
        super(new PacketContainer(TYPE), TYPE);
        handle.getModifier().writeDefaults();
    }
 
    public WrapperPlayServerNamedEntitySpawn(PacketContainer packet) {
        super(packet, TYPE);
    }
 
    public WrapperPlayServerNamedEntitySpawn(Player player) {
        super(fromPlayer(player), TYPE);
    }
 
    // Useful constructor
    private static PacketContainer fromPlayer(Player player) {
        if (entityConstructor == null)
            entityConstructor = ProtocolLibrary.getProtocolManager().createPacketConstructor(TYPE, player);
        return entityConstructor.createPacket(player);
    }
 
    /**
    * Retrieve player ID.
    * @return The current EID
    */
    public int getEntityID() {
        return handle.getIntegers().read(0);
    }
 
    /**
    * Set player ID.
    * @param value - new value.
    */
    public void setEntityID(int value) {
        handle.getIntegers().write(0, value);
    }
 
    /**
    * Retrieve the player's entity object.
    * @param world - the word the player has joined.
    * @return The player's entity.
    */
    public Entity getEntity(World world) {
        return handle.getEntityModifier(world).read(0);
    }
 
    /**
    * Retrieve the player's entity object.
    * @param event - the packet event.
    * @return The player's entity.
    */
    public Entity getEntity(PacketEvent event) {
        return getEntity(event.getPlayer().getWorld());
    }
 
    /**
    * Retrieve the player name.
    * <p>
    * Max length of 16.
    * @return The current player Name, or NULL if not set.
    */
    public String getPlayerName() {
        WrappedGameProfile profile = getProfile();
        return profile != null ? profile.getName() : null;
    }
 
    /**
    * Set the player name.
    * <p>
    * Max length of 16.
    * @param value - new value.
    */
    public void setPlayerName(String value) {
        if (value != null && value.length() > 16)
            throw new IllegalArgumentException("Maximum player name lenght is 16 characters.");
        setProfile(new WrappedGameProfile(getPlayerUUID(), value));
    }
 
    /**
    * Retrieve the UUID of the player.
    * @return The UUID, or NULL if not set.
    */
    public String getPlayerUUID() {
        WrappedGameProfile profile = getProfile();
        return profile != null ? profile.getId() : null;
    }
 
    /**
    * Set the UUID of the player.
    * @param uuid - the UUID.
    */
    public void setPlayerUUID(String uuid) {
        setProfile(new WrappedGameProfile(uuid, getPlayerName()));
    }
 
    /**
    * Retrieve player's full profile.
    * @return The spawner player's profile.
    */
    public WrappedGameProfile getProfile() {
        return handle.getGameProfiles().read(0);
    }
 
    /**
    * Set the spawned player's profile.
    * @param value - new profile.
    */
    public void setProfile(WrappedGameProfile value) {
        handle.getGameProfiles().write(0, value);
    }
 
    /**
    * Retrieve the position of the spawned entity as a vector.
    * @return The position as a vector.
    */
    public Vector getPosition() {
        return new Vector(getX(), getY(), getZ());
    }
 
    /**
    * Set the position of the spawned entity using a vector.
    * @param position - the new position.
    */
    public void setPosition(Vector position) {
        setX(position.getX());
        setY(position.getY());
        setZ(position.getZ());
    }
 
    /**
    * Retrieve the x axis of the position.
    * <p>
    * Note that the coordinate is rounded off to the nearest 1/32 of a meter.
    * @return The current X
    */
    public double getX() {
        return handle.getIntegers().read(1) / 32.0D;
    }
 
    /**
    * Set the x axis of the position.
    * @param value - new value.
    */
    public void setX(double value) {
        handle.getIntegers().write(1, (int) Math.floor(value * 32.0D));
    }
 
    /**
    * Retrieve the y axis of the position.
    * <p>
    * Note that the coordinate is rounded off to the nearest 1/32 of a meter.
    * @return The current y
    */
    public double getY() {
        return handle.getIntegers().read(2) / 32.0D;
    }
 
    /**
    * Set the y axis of the position.
    * @param value - new value.
    */
    public void setY(double value) {
        handle.getIntegers().write(2, (int) Math.floor(value * 32.0D));
    }
 
    /**
    * Retrieve the z axis of the new position.
    * <p>
    * Note that the coordinate is rounded off to the nearest 1/32 of a meter.
    * @return The current z
    */
    public double getZ() {
        return handle.getIntegers().read(3) / 32.0D;
    }
 
    /**
    * Set the z axis of the new position.
    * @param value - new value.
    */
    public void setZ(double value) {
        handle.getIntegers().write(3, (int) Math.floor(value * 32.0D));
    }
 
    /**
    * Retrieve the yaw of the spawned entity.
    * @return The current Yaw
    */
    public float getYaw() {
        return (handle.getBytes().read(0) * 360.F) / 256.0F;
    }
 
    /**
    * Set the yaw of the spawned entity.
    * @param value - new yaw.
    */
    public void setYaw(float value) {
        handle.getBytes().write(0, (byte) (value * 256.0F / 360.0F));
    }
 
    /**
    * Retrieve the pitch of the spawned entity.
    * @return The current pitch
    */
    public float getPitch() {
        return (handle.getBytes().read(1) * 360.F) / 256.0F;
    }
 
    /**
    * Set the pitch of the spawned entity.
    * @param value - new pitch.
    */
    public void setPitch(float value) {
        handle.getBytes().write(1, (byte) (value * 256.0F / 360.0F));
    }
 
    /**
    * Retrieve the item the player is currently holding.
    * <p>
    * Note that this should be 0 for "no item", unlike -1 used in other packets. A negative value crashes clients.
    * @return The current item.
    */
    public short getCurrentItem() {
        return handle.getIntegers().read(4).shortValue();
    }
 
    /**
    * Set the item the player is currently holding.
    * <p>
    * Note that this should be 0 for "no item", unlike -1 used in other packets. A negative value crashes clients.
    * @param value - new value.
    */
    public void setCurrentItem(short value) {
        handle.getIntegers().write(4, (int) value);
    }
 
    /**
    * Retrieve the associated metadata object.
    * <p>
    * Note that the 1.3 client crashes on packets with no metadata, but the server can send any metadata
    * key of 0, 1 or 8 and the client is fine.
    * @return The current metadata.
    */
    public WrappedDataWatcher getMetadata() {
        return handle.getDataWatcherModifier().read(0);
    }
 
    /**
    * Set the associated metadata object.
    * <p>
    * Note that the 1.3 client crashes on packets with no metadata, but the server can send any metadata
    * key of 0, 1 or 8 and the client is fine..
    * @param value - new value.
    */
    public void setMetadata(WrappedDataWatcher value) {
        handle.getDataWatcherModifier().write(0, value);
    }
 
    @Override
    public PacketContainer getHandle() {
        Preconditions.checkNotNull(getPlayerName(), "Must specify a player name.");
        Preconditions.checkNotNull(getPlayerUUID(), "Must specify a player UUID.");
        return super.getHandle();
    }
}

Class: Abstract Packet

Code:java

/*
*  PacketWrapper - Contains wrappers for each packet in Minecraft.
*  Copyright (C) 2012 Kristian S. Stangeland
*
*  This program is free software; you can redistribute it and/or modify it under the terms of the
*  GNU Lesser General Public License as published by the Free Software Foundation; either version 2 of
*  the License, or (at your option) any later version.
*
*  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
*  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*  See the GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License along with this program;
*  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
*  02111-1307 USA
*/
 
package com.gong.main;
 
import java.lang.reflect.InvocationTargetException;
 
import org.bukkit.entity.Player;
 
import com.comphenix.protocol.PacketType;
import com.comphenix.protocol.ProtocolLibrary;
import com.comphenix.protocol.events.PacketContainer;
import com.google.common.base.Objects;
 
public abstract class AbstractPacket {
    // The packet we will be modifying
    protected PacketContainer handle;
 
    /**
    * Constructs a new strongly typed wrapper for the given packet.
    * @param handle - handle to the raw packet data.
    * @param type - the packet type.
    */
    protected AbstractPacket(PacketContainer handle, PacketType type) {
        // Make sure we're given a valid packet
        if (handle == null)
            throw new IllegalArgumentException("Packet handle cannot be NULL.");
        if (!Objects.equal(handle.getType(), type))
            throw new IllegalArgumentException(
                    handle.getHandle() + " is not a packet of type " + type);
 
        this.handle = handle;
    }
 
    /**
    * Retrieve a handle to the raw packet data.
    * @return Raw packet data.
    */
    public PacketContainer getHandle() {
        return handle;
    }
 
    /**
    * Send the current packet to the given receiver.
    * @param receiver - the receiver.
    * @throws RuntimeException If the packet cannot be sent.
    */
    public void sendPacket(Player receiver) {
        try {
            ProtocolLibrary.getProtocolManager().sendServerPacket(receiver, getHandle());
        } catch (InvocationTargetException e) {
            throw new RuntimeException("Cannot send packet.", e);
        }
    }
 
    /**
    * Simulate receiving the current packet from the given sender.
    * @param sender - the sender.
    * @throws RuntimeException If the packet cannot be received.
    */
    public void recievePacket(Player sender) {
        try {
            ProtocolLibrary.getProtocolManager().recieveClientPacket(sender, getHandle());
        } catch (Exception e) {
            throw new RuntimeException("Cannot recieve packet.", e);
        }
    }
}

 

Trevor1134
I think this will fix it: EDIT: Nevermind the guy above posted a class
https://github.com/aadnk/PacketWrapper

 

TheMrGong Thank you. It now spawns! My only issue is that it won't set a custom skin?

 

The name is what skin is displayed. Such as, "TheMrGong" will display my skin, "seifnsei" will display some skin, etc.

As far as I know you cant make a custom skin since skins come from minecrafts skin server.

 

TheMrGong NPCLibrary does this using NPCProfile (name does not match skin)

 

Goblom How would you spawn, lets say "TheMrGong" but with someone elses skin then?

 

TheMrGong
The Bukkit GameProfile.
You can overwrite it and create your custom one.
You can assign different names, uuids, and skin uuids.
This is how lenis0012 does it.
https://github.com/lenis0012/NPCFac...enis0012/bukkit/npc/NPCProfile.java#L102-L107

There is also a "signature" that you have to handle for this to work I believe
EDIT: You may also need a custom NetworkManager

 

Ah.

 

Basicly its easier to shade my NPCFactory in to your project.
It doesn't mean you need an extra download or jar, thats why its so fancy