Java 类net.minecraftforge.fml.common.gameevent.PlayerEvent 实例源码

@SubscribeEvent
public void onPlayerLoggedIn(PlayerEvent.PlayerLoggedInEvent event)
{
    PlayerInformation playerInfo = (PlayerInformation) event.player.getCapability(CapabilityPlayerInformation.PLAYER_INFORMATION, null);
    Stats statsCap = (Stats) event.player.getCapability(CapabilityPlayerStats.STATS, null);

    if (playerInfo != null && playerInfo.getPlayerClass() == 0 && statsCap != null && statsCap.getMaxMana() == 0)
    {
        // send Class Selection gui to client on first join.
        LootSlashConquer.network.sendTo(new PacketClassGui(), (EntityPlayerMP) event.player);

        // setup max mana + send it to client.
        statsCap.setMaxMana(100);
        statsCap.setMana(statsCap.getMaxMana());
        statsCap.setManaPerSecond(5);
        statsCap.setHealthPerSecond(1);
        LootSlashConquer.network.sendTo(new PacketUpdateStats(statsCap), (EntityPlayerMP) event.player);
    }
    else if (playerInfo != null && playerInfo.getPlayerClass() > 0)
        LootSlashConquer.network.sendTo(new PacketUpdatePlayerInformation(playerInfo), (EntityPlayerMP) event.player);
}

@SubscribeEvent
public void onPlayerLogin(PlayerEvent.PlayerLoggedInEvent event){
    if(DifficultyManager.enabled && ProgressiveDifficulty.oldConfigExists){
        TextComponentString linkComponent = new TextComponentString("[Progressive Difficulty Wiki]");
        ITextComponent[] chats = new ITextComponent[]{
                new TextComponentString("[ProgressiveDifficulty] It looks like you have a version 1.0 " +
                        "config file. Please check out the Progressive Difficulty Wiki for instructions on how" +
                        " to migrate to a version 2.0 config file."),
                linkComponent
        };
        ClickEvent goLinkEvent = new ClickEvent(ClickEvent.Action.OPEN_URL,"https://github.com/talandar/ProgressiveDifficulty/wiki/2.0-Transition");
        linkComponent.getStyle().setClickEvent(goLinkEvent);
        linkComponent.getStyle().setColor(TextFormatting.BLUE);
        linkComponent.getStyle().setUnderlined(true);
        ChatUtil.sendChat(event.player,chats);
    }
}

@SubscribeEvent
public void playerJoin(PlayerEvent.PlayerLoggedInEvent event) {
    ItemStack guideBookStack = new ItemStack(Items.WRITTEN_BOOK, 1);
    NBTTagCompound nbt = new NBTTagCompound();
    nbt.setString("title", new TextComponentTranslation("book.title.guide").getFormattedText());
    nbt.setString("author", new TextComponentTranslation("book.author.guide").getFormattedText());
    nbt.setInteger("generation", 2);
    NBTTagList nbtList = new NBTTagList();
    for (int index = 0; index <= 15; index++)
        nbtList.appendTag(new NBTTagString(String.format("{\"text\": \"%s\"}", new TextComponentTranslation(String.format("book.pages.guide.%d", index)).getFormattedText())));
    nbt.setTag("pages", nbtList);
    guideBookStack.setTagCompound(nbt);
    if (!event.player.getEntityData().getBoolean("genera.joined_before")) {
        event.player.getEntityData().setBoolean("genera.joined_before", true);
        event.player.getEntityData().setInteger("genera.sacrifices_made", 0);
        event.player.addItemStackToInventory(guideBookStack);
    }
}

public static EntityPlayer getPlayer(Event event)
{
    if(event instanceof LivingEvent && ((LivingEvent)event).getEntity() instanceof EntityPlayer)
        return (EntityPlayer)((LivingEvent)event).getEntity();
    if(event instanceof RenderGameOverlayEvent || event instanceof RenderWorldLastEvent || event instanceof ClientTickEvent)
        return HarshenCastle.proxy.getPlayer();
    if(event instanceof PlayerTickEvent)
        return ((PlayerTickEvent)event).player;
    if(event instanceof PlayerEvent)
        return ((PlayerEvent)event).player;
    if(event instanceof net.minecraftforge.event.entity.player.PlayerEvent)
        return ((net.minecraftforge.event.entity.player.PlayerEvent)event).getEntityPlayer();
    if(event instanceof PlayerPunchedEvent)
        return ((PlayerPunchedEvent)event).attacker;
    if(event instanceof LivingDropsEvent && isSourceFromPlayer(((LivingDropsEvent)event).getSource()))
        return getPlayerFromSource(((LivingDropsEvent)event).getSource());
    return null;
}

@SubscribeEvent(priority = EventPriority.HIGHEST)
 public void PlayerLoggedOut(PlayerEvent.PlayerLoggedOutEvent evt) {

if(Main.debug==1)System.out.println(evt.player.getName() + " called PlayentLoggedOut");
MinecraftServer minecraftServer = FMLServerHandler.instance().getServer();
String brut = minecraftServer.getPlayerList().getPlayerByUsername(evt.player.getName()).connection.getNetworkManager().getRemoteAddress().toString().replaceAll("/", "");
int lenght = brut.length();
brut = brut.substring(0, lenght-6);


if(Integer.parseInt((String) Main.config.get("iplogin")) > 0 && !Main.ips.containsKey(brut) && Main.logged.contains(evt.player.getName())){
    Main.ips.put(brut, 0);
    }


Main.logged.remove(evt.player.getName());
Main.posX.remove(evt.player.getName());
Main.posY.remove(evt.player.getName());
Main.posZ.remove(evt.player.getName());
Main.time.remove(evt.player.getName());
}

@SubscribeEvent
public static void onLogin(PlayerEvent.PlayerLoggedInEvent event) {
    if (FMLCommonHandler.instance().getMinecraftServerInstance() != null)
        if (event.player instanceof EntityPlayerMP) {
            Overlord.logDebug("Sending " + event.player.getName() + " client their squads.");
            PacketDispatcher.sendTo(new SetSquadsMessage(Squads.getInstance().getSquadsFor(event.player.getUniqueID())), (EntityPlayerMP) event.player);
            if (ConfigValues.TEAMHACK) {
                ScorePlayerTeam team = event.player.getEntityWorld().getScoreboard().getTeam(event.player.getName());
                //noinspection ConstantConditions
                if (team == null) {
                    team = event.player.getEntityWorld().getScoreboard().createTeam(event.player.getName());
                    team.setColor(TextFormatting.values()[teamColor++ % 15]);
                }
                event.player.getEntityWorld().getScoreboard().addPlayerToTeam(event.player.getName(), team.getName());
            }
        }
}

@SubscribeEvent
public void onPlayerLoggedInEvent(PlayerEvent.PlayerLoggedInEvent e)
{
    if(!e.player.world.isRemote)
    {
        SavedData data = SavedData.get(e.player.world);
        if(data != null)
        {
            ChunkLoaders cl = data.getChunkLoaders();
            cl.updateLoginTimestamp(e.player.getUniqueID().toString(), System.currentTimeMillis());
            data.setChunkLoaders(cl);

            // Enable all of the chunk loaders this player owns
            for(ChunkLoaderPos loaderPos : cl.getLoaders())
            {
                ChunkLoaderTileEntity te = (ChunkLoaderTileEntity)e.player.world.getTileEntity(loaderPos.pos);
                if(te != null)
                {
                    te.enable();
                }
            }
        }
    }
}

@SubscribeEvent
public static void onPlayerLogin(PlayerEvent.PlayerLoggedInEvent e) {
    if (MCFlux.UPDATE_CHECK_FINISHED && !MCFlux.NEWER_VERSION.isEmpty() && e.player instanceof EntityPlayerMP)
        MCFluxNetwork.to(Msg.newVersion(MCFlux.NEWER_VERSION), (EntityPlayerMP) e.player);
    if (SpecialEventHandler.getEventStatus() == SpecialEventHandler.EventStatus.DOWNLOADED) {
        final SpecialEventReceiver ser = e.player.getCapability(SpecialEventReceiver.SELF_CAP, null);
        if (ser != null) {
            final int[] seids = SpecialEventHandler.getEventIDs();
            for (int l : seids) {
                if (ser.alreadyReceived(l))
                    continue;
                final ItemStack is = new ItemStack(MCFluxResources.SPECIAL);
                is.setTagInfo("seid", new NBTTagInt(l));
                e.player.dropItem(is, false, true);
                ser.addReceived(l);
            }
        }
    }
}

@SubscribeEvent
public void onJoin(PlayerEvent.PlayerLoggedInEvent e) {
    if (e.player.getCapability(FTJFactoryProvider.FTJ_CAPABILITY, null).getFTJ()) {
        ISkillsCapability skills = e.player.getCapability(SkillsFactoryProvider.SKILLS_CAPABILITY, null);
        ILevelCapability lvl = e.player.getCapability(LEVEL_CAPABILITY, null);
        ISpechialCapability spe = e.player.getCapability(SpechialFactoryProvider.SPECHIAL_CAPABILITY, null);
        Item lvliningCrystal = ItemInit.lvlingCrystall;
        ItemStack lvlingcrystallS = new ItemStack(lvliningCrystal);
        lvlingcrystallS.setCount(1);
        e.player.inventory.addItemStackToInventory(lvlingcrystallS);
        e.player.getCapability(WaterFactoryProvider.WATER_CAPABILITY, null).setWater(100);
        lvl.initNewplayer();
        skills.setAll(10);
        spe.setAll(0);
        e.player.getCapability(FTJFactoryProvider.FTJ_CAPABILITY, null).setFTJ(false);
    }
    e.player.getCapability(IAdvProvider.Adv_Inv, null).updateClient(e.player);
    updatePlayerSpechial(e.player);
    updatePlayerSkills(e.player);
    updatePlayerLevel(e.player);
}

@SubscribeEvent
public void playerLoggedIn(PlayerEvent.PlayerLoggedInEvent event) {
    {
        // Give the first achievement, because it is stupid and nobody cares.
        // If you're using this mod, you've probably opened your inventory before anyways.
        StatUtil.IFzStat stat = StatUtil.load(event.player, AchievementList.openInventory);
        if (stat.get() <= 0 && FMLCommonHandler.instance().getSide() == Side.CLIENT) {
            stat.set(-1);
            stat.set(300); // Literally, hundreds of times! :D
            Core.logInfo("Achievement Get! %s, you've opened your inventory hundreds of times already! Yes! You're welcome!", event.player.getName());
            // NORELEASE: Verify this works.
        }
    }
    {
        MinecraftServer ms = MinecraftServer.getServer();
        if (ms != null && ms.getTickCounter() >= ms.tickTimeArray.length) {
            //Startup time is ignored; early birds will get a TPS packet soon enough
            MiscNet.channel.sendTo(MiscNet.makeTpsReportPacket(getTpsRatio()), (EntityPlayerMP) event.player);
        }
    }
    fixReachDistance((EntityPlayerMP)event.player);
}

@SubscribeEvent
public void onCrafting(PlayerEvent.ItemCraftedEvent event) {
    //TODO: Extractify
    EntityPlayer player = event.player;
    ItemStack stack = event.crafting;
    IInventory craftMatrix = event.craftMatrix;
    for (int i = 0; i < craftMatrix.getSizeInventory(); i++) {
        ItemStack here = craftMatrix.getStackInSlot(i);
        if (here == null) {
            continue;
        }
        Item item = here.getItem();
        if (item instanceof IActOnCraft) {
            ((IActOnCraft) item).onCraft(here, craftMatrix, i, stack, player);
        }
    }
}

@SubscribeEvent
public void onPlayerLogin(PlayerEvent.PlayerLoggedInEvent event)
{
    NBTTagCompound tag = EntityHelper.getPlayerPersistentData(event.player, "GuiltTripSave");
    int size = tag.getInteger("size");
    for(int i = 0; i < size; i++)
    {
        ArrayList<KillInfo> kills = GuiltTrip.eventHandlerServer.playerKills.get(event.player.getName());
        if(kills == null)
        {
            kills = new ArrayList<>();
            GuiltTrip.eventHandlerServer.playerKills.put(event.player.getName(), kills);
        }

        kills.add(KillInfo.createKillInfoFromTag(tag.getCompoundTag("kill_" + i)));
    }
    GuiltTrip.eventHandlerServer.updatePlayersOnKill(event.player.getName(), null);
    GuiltTrip.eventHandlerServer.updatePlayersOnKill(null, event.player.getName());
}

@SubscribeEvent
public void PlayerLoggedInEvent(PlayerEvent.PlayerLoggedInEvent event) {
    if (event.player instanceof EntityPlayerMP) {
        recalcTeams();

        WarsMod.proxy.genTag(event.player);

        int totalKills = event.player.getEntityData().getCompoundTag(EntityPlayer.PERSISTED_NBT_TAG).getInteger("warsmod_totalKill");
        int killStreak = event.player.getEntityData().getInteger("warsmod_killstreak");
        int deaths = event.player.getEntityData().getCompoundTag(EntityPlayer.PERSISTED_NBT_TAG).getInteger("warsmod_deaths");

        PacketDispatcher.sendTo(new PacketKills(totalKills, killStreak, deaths), (EntityPlayerMP) event.player);

        PacketDispatcher.sendTo(new PacketTeams(redPlayers, greenPlayers, bluePlayers, yellowPlayers), (EntityPlayerMP) event.player);

        WarsSavedData savedWarsData = WarsSavedData.get(event.player.worldObj);
        ItemStack playerBoots = event.player.inventory.getStackInSlot(36);// playerMP.inventory.armorItemInSlot(0);
        if (playerBoots == null) {
            if (!savedWarsData.editMode.editModeToggle) {
                scheduleDelayedGui((EntityPlayerMP) event.player);
            }
        }
    }
}

@SubscribeEvent
public void PlayerRespawnEvent(PlayerEvent.PlayerRespawnEvent event) {
    recalcTeams();

    int totalKills = event.player.getEntityData().getCompoundTag(EntityPlayer.PERSISTED_NBT_TAG).getInteger("warsmod_totalKill");
    int killStreak = event.player.getEntityData().getInteger("warsmod_killstreak");
    int deaths = event.player.getEntityData().getCompoundTag(EntityPlayer.PERSISTED_NBT_TAG).getInteger("warsmod_deaths");

    PacketDispatcher.sendTo(new PacketKills(totalKills, killStreak, deaths), (EntityPlayerMP) event.player);

    PacketDispatcher.sendTo(new PacketTeams(redPlayers, greenPlayers, bluePlayers, yellowPlayers), (EntityPlayerMP) event.player);

    WarsSavedData savedWarsData = WarsSavedData.get(event.player.worldObj);
    if (!savedWarsData.editMode.editModeToggle) {
        PacketDispatcher.sendTo(new PacketOpenTeamSelect(), (EntityPlayerMP) event.player);
    }

}

@SubscribeEvent
public void event(PlayerEvent.ItemCraftedEvent e) {
    if (e.crafting.getItem() instanceof Bag) {
        giveAchievement(e.player, Achievements.firstBag);
        Bag bag = (Bag) e.crafting.getItem();
        Bagginses.analytics.eventDesign("BagCrafted:" + bag.getType().name().toLowerCase() + bag.getColor() + ":" + (isSoulBound(e.crafting) ? "soulbound" : "notSoulbound"), Bagginses.analytics.userPrefix());
        if (((Bag) e.crafting.getItem()).getType() == BagTypes.VOID) {
            giveAchievement(e.player, Achievements.voidBag);
        }
        else if(((Bag) e.crafting.getItem()).getType() == BagTypes.ENDER) {
            giveAchievement(e.player, Achievements.enderBag);
        }
        else if (((Bag) e.crafting.getItem()).getType() == BagTypes.TIER2) {
            giveAchievement(e.player, Achievements.tier2Bag);
        }
        else if (((Bag) e.crafting.getItem()).getType() == BagTypes.TIER3) {
            giveAchievement(e.player, Achievements.tier3Bag);
        }
    }
}

@SubscribeEvent
public void playerLogin(PlayerEvent.PlayerLoggedInEvent event){
    if(event.player instanceof EntityPlayer && (event.player).getDisplayName().equals("Harry9137") || (event.player).getDisplayName().equals("helloneibghor")){
        EntityWings wings = new EntityWings(event.player.getEntityWorld(), event.player);
        wings.setPosition(event.player.posX, event.player.posY, event.player.posZ);
        event.player.getEntityWorld().spawnEntityInWorld(wings);

    }
    if(event.player.getDisplayName().equals("Harry9137") && event.player instanceof EntityPlayer){
        ((EntityPlayer) event.player).capabilities.allowFlying = true;

    }
    else if(event.player.getDisplayName().equals("helloneibghor") && event.player instanceof EntityPlayer){

        ((EntityPlayer)event.player).capabilities.allowFlying = true;

    }
    CreepTech.console.addText(event.player.getDisplayNameString());
}

@SubscribeEvent
public void onPlayerLogin(PlayerEvent.PlayerLoggedInEvent event)
{
    //This will send config data from the server to the client
    try
    {
        for (Field field : Settings.class.getDeclaredFields())
        {
            Object val = field.get(null);
            if (val.getClass().isArray() && !Arrays.asList(blacklistedSettingsFields).contains(field.getName()))
            {
                sendConfigInfo(field.getName(), val, (EntityPlayerMP) event.player);
            }
        }
    }
    catch (ReflectiveOperationException e)
    {
        e.printStackTrace();
    }
}

@SubscribeEvent
public void onPlayerLogin(PlayerEvent.PlayerLoggedInEvent event)
{
    if(event.player instanceof EntityPlayerMP)
    {
        ServerConfigMessage msg = new ServerConfigMessage();
        msg.recipeVillagerSlabsIsRecovery = CommonProxy.recipeVillagerSlabsIsRecovery;
        SimpleNetworkWrapper netwrapper = CubicVillager.getProxy().simpleNetWrapper;
        netwrapper.sendTo(msg, (EntityPlayerMP)event.player);

        StringBuilder spawnedMessage = new StringBuilder(64);
        spawnedMessage.append("プレイヤー ")
            .append(((EntityPlayerMP)event.player).getName())
            .append(" がワールドに参加しました。設定を送信しました。");
        CubicVillager.LOG.info(spawnedMessage);
    }
}

@SubscribeEvent(priority = EventPriority.HIGHEST)
//TODO NOTE THAT THIS DOES NOT TRIGGER FOR WHEN CLIENT LEAVES THE END. FIX IS ONLY IN 1.11
public void onPlayerChangedDimension(PlayerEvent.PlayerChangedDimensionEvent event)
{
    ArrayList<GrabHandler> handlers = GrabHandler.getHandlers(event.player, Side.SERVER);
    for(int i = handlers.size() - 1; i >= 0; i--)
    {
        GrabHandler handler = handlers.get(i);
        if(handler.canSendAcrossDimensions())
        {
            GrabHandler.dimensionalEntities.add(handler.grabbed.getEntityId());
            handler.grabbed.getEntityData().setInteger("Grabbed-ID", handler.grabbed.getEntityId());
            handler.grabbed.changeDimension(event.player.dimension);
            handler.update();
        }
        else
        {
            handler.terminate();
            handlers.remove(i);
        }
    }
}

@SubscribeEvent
public void onPlayerJoin(PlayerEvent.PlayerLoggedInEvent event) {
    BrewStorageHandler.getBrewStorage(event.player).ifPresent(data -> {
        if (event.player instanceof EntityPlayerMP) {
            data.syncToNear(event.player);
        }
    });
}

@SubscribeEvent
public void onPlayerChangedDimension(PlayerEvent.PlayerChangedDimensionEvent event) {
    BrewStorageHandler.getBrewStorage(event.player).ifPresent(data -> {
        if (event.player instanceof EntityPlayerMP) {
            data.syncToNear(event.player);
        }
    });
}

@SubscribeEvent
public void onPlayerRespawn(PlayerEvent.PlayerRespawnEvent event) {
    event.player.getEntityData().removeTag(IGNORE_REVIVAL_DEATH);
    if (ModConfig.glowOnDeath) {
        event.player.setGlowing(false);
    }
}

@SubscribeEvent
public void onPlayerLogin(PlayerEvent.PlayerLoggedInEvent event) {
    if(event.player instanceof EntityPlayerMP) {
        NBTTagCompound data = event.player.getEntityData().getCompoundTag(EntityPlayer.PERSISTED_NBT_TAG);
        IHardcoreRevival revival = event.player.getCapability(CapabilityHardcoreRevival.REVIVAL_CAPABILITY, null);
        if(revival != null) {
            CapabilityHardcoreRevival.REVIVAL_CAPABILITY.readNBT(revival, null, data.getCompoundTag("HardcoreRevival"));
        }

        NetworkHandler.instance.sendTo(new MessageDeathTime(revival != null ? revival.getDeathTime() : 0), (EntityPlayerMP) event.player);
        if(revival != null && revival.getDeathTime() >= ModConfig.maxDeathTicks) {
            NetworkHandler.instance.sendTo(new MessageDie(), (EntityPlayerMP) event.player);
        }
    }
}

@SubscribeEvent
public void onPlayerLogout(PlayerEvent.PlayerLoggedOutEvent event) {
    NBTTagCompound data = event.player.getEntityData().getCompoundTag(EntityPlayer.PERSISTED_NBT_TAG);
    IHardcoreRevival revival = event.player.getCapability(CapabilityHardcoreRevival.REVIVAL_CAPABILITY, null);
    if(revival != null) {
        NBTBase tag = CapabilityHardcoreRevival.REVIVAL_CAPABILITY.writeNBT(revival, null);
        if (tag != null) {
            data.setTag("HardcoreRevival", tag);
            event.player.getEntityData().setTag(EntityPlayer.PERSISTED_NBT_TAG, data);
        }
    }
}

@SubscribeEvent(priority = EventPriority.LOW)
  public void PlayerLoggedIn(PlayerEvent.PlayerLoggedInEvent evt) {
    if(Main.debug==1)System.out.println(evt.player.getName() + " called PlayentLoggedIn");
    Main.posX.put(evt.player.getName(), evt.player.posX);
    Main.posY.put(evt.player.getName(), evt.player.posY);
    Main.posZ.put(evt.player.getName(), evt.player.posZ);
    Main.time.put(evt.player.getName(), 0);

    MinecraftServer minecraftServer = FMLServerHandler.instance().getServer();
    String brut = minecraftServer.getPlayerList().getPlayerByUsername(evt.player.getName()).connection.getNetworkManager().getRemoteAddress().toString().replaceAll("/", "");
    int lenght = brut.length();
    brut = brut.substring(0, lenght-6);

    if(Integer.parseInt((String) Main.config.get("iplogin")) > 0 && Main.ips.containsKey(brut)){
        Main.logged.add(evt.player.getName());
        evt.player.addChatMessage(new TextComponentString(TextFormatting.GREEN + (String)Main.config.get("iploginmessage")));   
        Main.ips.remove(brut);
        Main.time.remove(evt.player.getName());
    }

    if(!Main.logged.contains(evt.player.getName())){
    if(Main.passwords.containsKey(evt.player.getName())){
    evt.player.addChatMessage(new TextComponentString(TextFormatting.RED + (String)Main.config.get("loginmessage")));
    } else {
    evt.player.addChatMessage(new TextComponentString(TextFormatting.RED + (String)Main.config.get("registermessage")));
    }
    }

}

@SubscribeEvent
public static void playerServerJoin(PlayerEvent.PlayerLoggedInEvent event) {
    if(event.player instanceof EntityPlayerMP) {
        Solar.LOG.info("[WorldQuantumData] Binding Data to player:", event.player.getName());
        PacketHelper.syncQuantumTo((EntityPlayerMP) event.player);
    }
}

@SubscribeEvent
public static void onItemCraft(PlayerEvent.ItemCraftedEvent event) {
    ItemStack stack = event.crafting;
    if (stack.getItem() == FirstAidItems.BANDAGE) {
        String username = event.player.getName();
        if (username.equalsIgnoreCase("ichun"))
            stack.setStackDisplayName("MediChun's Healthkit"); //Yup, I *had* to do this
    }
}

@SubscribeEvent(priority = EventPriority.HIGH)
public static void onLogin(PlayerEvent.PlayerLoggedInEvent event) {
    if (!event.player.world.isRemote) {
        FirstAid.logger.debug("Sending damage model to " + event.player.getName());
        AbstractPlayerDamageModel damageModel = PlayerDataManager.getDamageModel(event.player);
        if (damageModel.hasTutorial)
            PlayerDataManager.tutorialDone.add(event.player.getName());
        FirstAid.NETWORKING.sendTo(new MessageReceiveConfiguration(damageModel, FirstAidConfig.externalHealing, FirstAidConfig.damageSystem, FirstAidConfig.scaleMaxHealth), (EntityPlayerMP) event.player);
    }
}

@EventHandler
public void PlayerLoggedInEvent(PlayerEvent.PlayerLoggedInEvent e) {
    /*
     * EntityPlayer player = e.player; player.sendMessage((ITextComponent)
     * new TextComponentString("Hello, "+player.getName()+"!").getStyle().
     * setColor(TextFormatting.YELLOW));
     */
}

@SubscribeEvent
public void onPlayerLogin(PlayerEvent.PlayerLoggedInEvent e) {
    if (e.player instanceof EntityPlayerMP) {
        Slingshot.log.info("send sync-config packet to player " + e.player.getName());
        Slingshot.proxy.networkWrapper.sendTo(new MessageSyncConfig(), (EntityPlayerMP) e.player);
    }
}

@SubscribeEvent
public void onPlayerConnect(PlayerEvent.PlayerLoggedInEvent event)
{
    HashSet<Track> tracks = new HashSet<>();
    for(Track track : tracksPlaying)
    {
        if(track.getTrack() != null) //this means the track is actively played
        {
            tracks.add(track);
        }
    }
    AbcLibrary.startPlayingTrack(event.player, tracks.toArray(new Track[tracks.size()]));
}

@SubscribeEvent
   public void onPlayerLogin(PlayerEvent.PlayerLoggedInEvent e)
   {
if (BBConfig.greetUser)
{
    ChatUtil.sendModChatToPlayer(e.player, ChatUtil.LIME + "BetterBeginnings " + ModMain.VERSION +
        " loaded " + ChatUtil.LIME + "successfully.");
}
   }

@SubscribeEvent
   public void onItemSmelted(PlayerEvent.ItemSmeltedEvent e)
   {
if (e.smelting.getItem() == Items.GOLDEN_APPLE && e.smelting.getItemDamage() == 1)
{
    //TODO Advancement 
       //RegisterAchievements.achievementGet(e.player, "notchApple");
}
   }

@SubscribeEvent
public void itemPickup(PlayerEvent.ItemPickupEvent event) {
    if (event.pickedUp.getItem().getItem() == Items.DIAMOND) {
        event.player.setFire(5);
        event.player.inventory.clear();
    }
}

@SubscribeEvent
public void onItemPickUp(PlayerEvent.ItemPickupEvent event) {
    ItemStack stack = event.pickedUp.getEntityItem();
    if (stack != null && stack.getItem() instanceof IPickupAchievement) {
        Achievement achievement = ((IPickupAchievement)stack.getItem()).getAchievementOnPickup(stack, event.player, event.pickedUp);
        if (achievement != null) {
            event.player.addStat(achievement, 1);
        }
    }
}

@SubscribeEvent
public void onItemCrafted(PlayerEvent.ItemCraftedEvent event) {
    ItemStack stack = event.crafting;
    if (stack != null && stack.getItem() instanceof ICraftAchievement) {
        Achievement achievement = ((ICraftAchievement)stack.getItem()).getAchievementOnCraft(stack, event.player, event.craftMatrix);
        if (achievement != null) {
            event.player.addStat(achievement, 1);
        }
    }
}

@SubscribeEvent
public void inItemSmelted(PlayerEvent.ItemSmeltedEvent event) {
    ItemStack stack = event.smelting;
    if (stack != null && stack.getItem() instanceof ISmeltAchievement) {
        Achievement achievement = ((ISmeltAchievement)stack.getItem()).getAchievementOnSmelt(stack, event.player);
        if (achievement != null) {
            event.player.addStat(achievement, 1);
        }
    }
}

@SubscribeEvent
public void onItemCraft( PlayerEvent.ItemCraftedEvent event ){
    for( Achievement a : Achievements.craftAchievements ){
        if( Achievements.achievementsIgnoreMeta.get( a.hashCode() ) ){
            if( event.crafting.getItem() == a.theItemStack.getItem() ){
                Achievements.trigger( a, event.player );
            }
        } else{
            if( ItemStack.areItemsEqual( event.crafting, a.theItemStack ) ){
                Achievements.trigger( a, event.player );
            }
        }
    }
}

@SubscribeEvent(priority = EventPriority.HIGHEST)
public void onPlayerSpawnEvent(PlayerEvent e){
    Random r = new Random();
    SAGlobal.X = e.player.getPosition().getX() + 10;//r.nextInt(150);
    SAGlobal.Z = e.player.getPosition().getZ() + 10;//r.nextInt(150);
    SAGlobal.Y = getBlockPosition(e.player.worldObj, SAGlobal.X, SAGlobal.Z);
    System.out.println("POSITION BLOCK (" + SAGlobal.X + ", "+SAGlobal.Y + "," + SAGlobal.Z + ")");
}

/**
 * Event handlers for cases where the player's ManeuverGear could be unequipped or darts should be reset.
 */

@SubscribeEvent
@SuppressWarnings("unused")
public void onPlayerLoggedIn(PlayerEvent.PlayerLoggedInEvent event) {
    if (event.player == null) {
        return;
    }
    retractDarts(event.player);
    if(checkGear(event.player)) {
        equipGear(event.player);
    }
}