IndexOF()

[krisadr]

[src=java]package instances.ChamberOfDelusionEast;

import com.l2world.gameserver.ai.CtrlIntention;
import com.l2world.gameserver.instancemanager.InstanceManager;
import com.l2world.gameserver.instancemanager.InstanceManager.InstanceWorld;
import com.l2world.gameserver.model.L2Party;
import com.l2world.gameserver.model.actor.L2Npc;
import com.l2world.gameserver.model.actor.L2Summon;
import com.l2world.gameserver.model.actor.instance.L2PcInstance;
import com.l2world.gameserver.model.quest.Quest;
import com.l2world.gameserver.model.quest.QuestState;
import com.l2world.gameserver.network.SystemMessageId;
import com.l2world.gameserver.network.serverpackets.SystemMessage;
import com.l2world.gameserver.util.Util;
import com.l2world.util.Rnd;

public class ChamberOfDelusionEast extends Quest
{

private class CDWorld extends InstanceWorld
{
private L2Npc manager,managera,managerb,managerc,managerd,managere,managerf,managerg,managerh,_aenkinel;
public CDWorld()
{
InstanceManager.getInstance().super();
}
}

private static final String qn = "ChamberOfDelusionEast";
private static final int INSTANCEID = 127; // this is the client number
//NPCs
private static final int GKSTART = 32658;
private static final int GKFINISH = 32664;
private static final int AENKINEL = 25690;
private static final int ROOMRB = 4;
private int rb = 0;
private int a;
public int instId = 0;
private int b;
private int g = 0;
private int h = 0;
private int c;
private class teleCoord {int instanceId; int x; int y; int z;}
private static final int[][] TELEPORT =
{
{ -122368,-152624,-6752},
{ -122368,-153504,-6752},
{ -120496,-154304,-6752},
{ -120496,-155184,-6752},
{ -121440,-154688,-6752},
{ -121440,-151328,-6752},
{ -120496,-153008,-6752},
{ -122368,-154800,-6752},
{ -121440,-153008,-6752}
};
private boolean checkConditions(L2PcInstance player)
{

L2Party party = player.getParty();
if (party == null)
{
player.sendPacket(new SystemMessage(2101));
return false;
}
if (party.getLeader() != player)
{
player.sendPacket(new SystemMessage(2185));
return false;
}
for (L2PcInstance partyMember : party.getPartyMembers())
{
if (partyMember.getLevel() < 80)
{
SystemMessage sm = new SystemMessage(2097);
sm.addPcName(partyMember);
party.broadcastToPartyMembers(sm);
return false;
}
if (!Util.checkIfInRange(1000, player, partyMember, true))
{
SystemMessage sm = new SystemMessage(2096);
sm.addPcName(partyMember);
party.broadcastToPartyMembers(sm);
return false;
}
}
return true;

}

private void teleportplayer(L2PcInstance player, teleCoord teleto)
{
player.getAI().setIntention(CtrlIntention.AI_INTENTION_IDLE);
player.setInstanceId(teleto.instanceId);
player.teleToLocation(teleto.x, teleto.y, teleto.z);
return;
}

private void teleportrnd(L2PcInstance player, CDWorld world)
{
int tp = Rnd.get(TELEPORT.length);
if (rb == 1&& tp == ROOMRB)
{
tp = Rnd.get(TELEPORT.length);
for (int i = 0; i < TELEPORT.length; i++)
{
if (i == tp)
{
for (L2PcInstance partyMember : player.getParty().getPartyMembers())
{
partyMember.getAI().setIntention(CtrlIntention.AI_INTENTION_IDLE);
partyMember.setInstanceId(instId);
partyMember.teleToLocation(TELEPORT[i][0], TELEPORT[i][1], TELEPORT[i][2]);
}
}
}
a = player.getX();
b = player.getY();
c = player.getZ();
}
else
{
for (int i = 0; i < TELEPORT.length; i++)
{
if (i == tp)
{
for (L2PcInstance partyMember : player.getParty().getPartyMembers())
{
partyMember.getAI().setIntention(CtrlIntention.AI_INTENTION_IDLE);
partyMember.setInstanceId(instId);
partyMember.teleToLocation(TELEPORT[i][0], TELEPORT[i][1], TELEPORT[i][2]);
}
}
}
a = player.getX();
b = player.getY();
c = player.getZ();
}

return;
}

protected void spawnState(CDWorld world)
{
world._aenkinel = addSpawn(AENKINEL, -121463,-155094,-6752, 0, false, 0, false, world.instanceId);
world._aenkinel.setIsNoRndWalk(false);
world.manager = addSpawn(32664,-121440,-154688,-6752,0,false,0,false,world.instanceId);
world.manager.setIsNoRndWalk(true);
world.managerb = addSpawn(32664,-122368,-153504,-6752,0,false,0,false,world.instanceId);
world.managerb.setIsNoRndWalk(true);
world.managerc = addSpawn(32664,-120496,-154304,-6752,0,false,0,false,world.instanceId);
world.managerc.setIsNoRndWalk(true);
world.managerd = addSpawn(32664,-120496,-155184,-6752,0,false,0,false,world.instanceId);
world.managerd.setIsNoRndWalk(true);
world.managere = addSpawn(32664,-121440,-151328,-6752,0,false,0,false,world.instanceId);
world.managere.setIsNoRndWalk(true);
world.managerf = addSpawn(32664,-120496,-153008,-6752,0,false,0,false,world.instanceId);
world.managerf.setIsNoRndWalk(true);
world.managerg = addSpawn(32664,-122368,-154800,-6752,0,false,0,false,world.instanceId);
world.managerg.setIsNoRndWalk(true);
world.managerh = addSpawn(32664,-121440,-153008,-6752,0,false,0,false,world.instanceId);
world.managerh.setIsNoRndWalk(true);
world.managera = addSpawn(32664,-122368,-152624,-6752,0,false,0,false,world.instanceId);
world.managera.setIsNoRndWalk(true);
}
protected int enterInstance(L2PcInstance player, String template)
{
int instanceId = 0;
//check for existing instances for this player
InstanceWorld world = InstanceManager.getInstance().getPlayerWorld(player);
//existing instance
if (world != null)
{
if (!(world instanceof CDWorld))
{
player.sendPacket(new SystemMessage(SystemMessageId.ALREADY_ENTERED_ANOTHER_INSTANCE_CANT_ENTER));
return 0;
}
teleCoord tele = new teleCoord();
tele.x = a;
tele.y = b;
tele.z = c;
tele.instanceId = world.instanceId;
teleportplayer(player,tele);
return instanceId;
}
//New instance
else
{
if (!checkConditions(player))
return 0;
L2Party party = player.getParty();
instanceId = InstanceManager.getInstance().createDynamicInstance(template);
world = new CDWorld();
world.instanceId = instanceId;
world.templateId = INSTANCEID;
world.status = 0;
InstanceManager.getInstance().addWorld(world);
_log.info("Chamber Of Delusion started " + template + " Instance: " + instanceId + " created by player: " + player.getName());
spawnState((CDWorld)world);
instId = world.instanceId;
for (L2PcInstance partyMember : party.getPartyMembers())
{
teleportrnd(partyMember,(CDWorld)world);
world.allowed.add(partyMember.getObjectId());
}

return instanceId;
}
}

protected void exitInstance(L2PcInstance player, teleCoord tele)
{
player.setInstanceId(0);
player.teleToLocation(tele.x, tele.y, tele.z);
L2Summon pet = player.getPet();
if (pet != null)
{
pet.setInstanceId(0);
pet.teleToLocation(tele.x, tele.y, tele.z);
}
}

public String onAdvEvent (String event, L2Npc npc, L2PcInstance player)
{
InstanceWorld tmpworld = InstanceManager.getInstance().getPlayerWorld(player);
if (tmpworld instanceof CDWorld)
{
CDWorld world = (CDWorld) tmpworld;
L2Party party = player.getParty();
instId = player.getInstanceId();
if (event.equalsIgnoreCase("tproom"))
{

for (L2PcInstance partyMember : party.getPartyMembers())
{
teleportrnd(partyMember,(CDWorld)world);
}

startQuestTimer("tproom1",480000,null,player);
h++;
}
else if (event.equalsIgnoreCase("tproom1"))
{

for (L2PcInstance partyMember : party.getPartyMembers())
{
teleportrnd(partyMember,(CDWorld)world);
}

startQuestTimer("tproom2",480000,null,player);
h++;
}
else if (event.equalsIgnoreCase("tproom2"))
{

for (L2PcInstance partyMember : party.getPartyMembers())
{
teleportrnd(partyMember,(CDWorld)world);
}

startQuestTimer("tproom3",480000,null,player);
h++;
}
else if (event.equalsIgnoreCase("tproom3"))
{

for (L2PcInstance partyMember : party.getPartyMembers())
{
teleportrnd(partyMember,(CDWorld)world);
}

}
else if ("7".equalsIgnoreCase(event))
{
if (g ==0)
{
if (h == 0)
{
cancelQuestTimers("tproom");
for (L2PcInstance partyMember : party.getPartyMembers())
{
teleportrnd(partyMember,(CDWorld)world);
}
startQuestTimer("tproom1",480000,null,player);
g =1;
}
else if (h == 1)
{
cancelQuestTimers("tproom1");
for (L2PcInstance partyMember : party.getPartyMembers())
{
teleportrnd(partyMember,(CDWorld)world);
}
startQuestTimer("tproom2",480000,null,player);
g =1;
}
else if (h == 2)
{
cancelQuestTimers("tproom2");
for (L2PcInstance partyMember : party.getPartyMembers())
{
teleportrnd(partyMember,(CDWorld)world);
}
startQuestTimer("tproom3",480000,null,player);
g =1;
}
else if (h == 3)
{
cancelQuestTimers("tproom3");
for (L2PcInstance partyMember : party.getPartyMembers())
{
teleportrnd(partyMember,(CDWorld)world);
}
g =1;
}
}
}

}
return "";
}

public String onKill( L2Npc npc, L2PcInstance player)
{
int npcId = npc.getNpcId();
if (rb == 0 && npcId == AENKINEL)
{
_log.info("kill");
rb = 1;

}
return "";
}
public final String onFirstTalk (L2Npc npc, L2PcInstance player)
{
return npc.getNpcId() + ".htm";
}

public String onTalk (L2Npc npc, L2PcInstance player)
{
int npcId = npc.getNpcId();
QuestState st = player.getQuestState(qn);
if (st == null)
st = newQuestState(player);
if (npcId == GKSTART)
{
enterInstance(player,"ChamberofDelusionEast.xml");
startQuestTimer("tproom",480000,null,player);
return "";
}
else if (npcId == GKFINISH)
{ InstanceWorld world = InstanceManager.getInstance().getPlayerWorld(player);
world.allowed.remove(world.allowed.indexOf(player.getObjectId()));
teleCoord tele = new teleCoord();
tele.instanceId = 0;
tele.x = -114592;
tele.y = -152509;
tele.z = -6723;
cancelQuestTimers("tproom");
cancelQuestTimers("tproom1");
cancelQuestTimers("tproom2");
cancelQuestTimers("tproom3");
for (L2PcInstance partyMember : player.getParty().getPartyMembers())
{
exitInstance(partyMember,tele);
}
}
return "";
}

public ChamberOfDelusionEast(int questId, String name, String descr)
{
super(questId, name, descr);

addStartNpc(GKSTART);
addTalkId(GKSTART);
addStartNpc(GKFINISH);
addFirstTalkId(GKFINISH);
addTalkId(GKFINISH);
addKillId(AENKINEL);
}

public static void main(String[] args)
{
new ChamberOfDelusionEast(-1,qn,"instances");
}
}[/src]
вытащил из одной сборки этот скрипт и попытался вставить в свою, но в эклипсе выскачила ошибка, адресованная indexOf что то вроде неправильного синтаксиса, вообщем наскока я понял строка
[src=java]world.allowed.remove(world.allowed.indexOf(player.getObjectId()));[/src]
удаляет у персонажей этот инстанс... чем можно заменить indexof?

[VISTALL]

[src=#java]
InstanceWorld
[/src]

дайте код

[krisadr]

Код:

/*
* This program is free software: you can redistribute it and/or modify it under the terms of the
* GNU General Public License as published by the Free Software Foundation, either version 3 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, see <http://www.gnu.org/licenses/>.
*/
package com.l2dc.gameserver.instancemanager;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Level;
import java.util.logging.Logger;

import javolution.io.UTF8StreamReader;
import javolution.util.FastMap;
import javolution.xml.stream.XMLStreamConstants;
import javolution.xml.stream.XMLStreamException;
import javolution.xml.stream.XMLStreamReaderImpl;
import com.l2dc.Config;
import com.l2dc.database.MiscDbTask;
import com.l2dc.gameserver.model.actor.instance.L2PcInstance;
import com.l2dc.gameserver.model.entity.Instance;
import com.l2dc.util.StringUtil;

/**
* @author evill33t, GodKratos
*
*/
public class InstanceManager
{
    
    /**
     * Logger.
     */
    private static final Logger _log = Logger.getLogger(InstanceManager.class.getName());
    /**
     * Map of instance ids and instances.
     */
    private Map<Integer, Instance> _instancesMap = new ConcurrentHashMap<Integer, Instance>();
    /**
     * Map of instance ids and worlds.
     */
    private Map<Integer, InstanceWorld> _instanceWorldsMap = new ConcurrentHashMap<Integer, InstanceWorld>();
    /**
     * Counter for creation of dynamic instances.
     */
    private final AtomicInteger _dynamicInstanceId = new AtomicInteger(300000);
    
    // InstanceId Names
    private final static Map<Integer, String> _instanceIdNames = new FastMap<Integer, String>();
    private Map<Integer, Map<Integer, Long>> _playerInstanceTimes = new FastMap<Integer, Map<Integer, Long>>();
    
    public static final String ADD_INSTANCE_TIME = "INSERT INTO character_instance_time (charId,instanceId,time) values (?,?,?) ON DUPLICATE KEY UPDATE time=?";
    public static final String RESTORE_INSTANCE_TIMES = "SELECT instanceId,time FROM character_instance_time WHERE charId=?";
    public static final String DELETE_INSTANCE_TIME = "DELETE FROM character_instance_time WHERE charId=? AND instanceId=?";
    
    public long getInstanceTime(int playerObjId, int id)
    {
        if (!getPlayerInstanceTimes().containsKey(playerObjId))
            restoreInstanceTimes(playerObjId);
        if (getPlayerInstanceTimes().get(playerObjId).containsKey(id))
            return getPlayerInstanceTimes().get(playerObjId).get(id);
        return -1;
    }
    
    public Map<Integer, Long> getAllInstanceTimes(int playerObjId)
    {
        if (!getPlayerInstanceTimes().containsKey(playerObjId))
            restoreInstanceTimes(playerObjId);
        return getPlayerInstanceTimes().get(playerObjId);
    }
    
    public void setInstanceTime(int playerObjId, int id, long time)
    {
        if (!_playerInstanceTimes.containsKey(playerObjId))
            restoreInstanceTimes(playerObjId);
        MiscDbTask.getInstance().setInstanceTime(this, playerObjId, id, time);
    }
    
    public void deleteInstanceTime(int playerObjId, int id)
    {
        MiscDbTask.getInstance().deleteInstanceTime(this, playerObjId, id);
    }
    
    public void restoreInstanceTimes(int playerObjId)
    {
        if (getPlayerInstanceTimes().containsKey(playerObjId))
            return; // already restored
        getPlayerInstanceTimes().put(playerObjId, new FastMap<Integer, Long>());
        MiscDbTask.getInstance().restoreInstanceTimes(this, playerObjId);
    }
    
    public String getInstanceIdName(int id)
    {
        if (_instanceIdNames.containsKey(id))
            return _instanceIdNames.get(id);
        return ("UnknownInstance");
    }
    
    private void loadInstanceNames()
    {
        InputStream in = null;
        try
        {
            in = new FileInputStream(Config.DATAPACK_ROOT + "/data/instancenames.xml");
            XMLStreamReaderImpl xpp = new XMLStreamReaderImpl();
            xpp.setInput(new UTF8StreamReader().setInput(in));
            for (int e = xpp.getEventType(); e != XMLStreamConstants.END_DOCUMENT; e = xpp.next())
            {
                if (e == XMLStreamConstants.START_ELEMENT)
                {
                    if (xpp.getLocalName().toString().equals("instance"))
                    {
                        Integer id = Integer.valueOf(xpp.getAttributeValue(null, "id").toString());
                        String name = xpp.getAttributeValue(null, "name").toString();
                        _instanceIdNames.put(id, name);
                    }
                }
            }
        }
        catch (FileNotFoundException e)
        {
            _log.log(Level.WARNING, "instancenames.xml could not be loaded: file not found", e);
        }
        catch (XMLStreamException xppe)
        {
            _log.log(Level.WARNING, "cannot read instancenames.xml file", xppe);
        }
        finally
        {
            try
            {
                in.close();
            }
            catch (Exception e)
            {
            }
        }
    }
    
    /**
     * Creates new instance of InstanceManager.
     */
    private InstanceManager()
    {
        _log.info("Initializing InstanceManager");
        loadInstanceNames();
        _log.info("Loaded " + _instanceIdNames.size() + " instance names");
        createWorld();
    }
    
    /**
     * Returns the single instance of InstanceManager.
     *
     * @return the single instance of InstanceManager
     */
    public static final InstanceManager getInstance()
    {
        return SingletonHolder.INSTANCE;
    }
    
    /**
     * Adds instance world to the collection of instance worlds.
     *
     * @param world
     *            instance world
     */
    public void addWorld(final InstanceWorld world)
    {
        _instanceWorldsMap.put(world.instanceId, world);
    }
    
    /**
     * Returns instance world for given <code>instanceId</code>.
     *
     * @param instanceId
     *            instance id
     *
     * @return instance world or null
     */
    public InstanceWorld getWorld(final int instanceId)
    {
        return _instanceWorldsMap.get(instanceId);
    }
    
    /**
     * Searches instances to find whether player can enter any of the instances. Returns first
     * instance world that player can enter.
     *
     * @param player
     *            player
     *
     * @return instance world or null
     */
    public InstanceWorld getPlayerWorld(final L2PcInstance player)
    {
        for (final InstanceWorld world : _instanceWorldsMap.values())
        {
            if (world == null)
                continue;
            if (world.allowed.contains(player.getObjectId()))
            {
                return world;
            }
        }
        
        return null;
    }
    
    public void createPlayerWorld(int instanceId, int templateId, int playerId, int status)
    {
        InstanceWorld world = new InstanceWorld();
        world.instanceId = instanceId;
        world.templateId = templateId;
        world.allowed.add(playerId);
        world.status = status;
        InstanceManager.getInstance().addWorld(world);
    }
    
    /**
     * Creates multiverse and universe for instance manager instance.
     */
    private void createWorld()
    {
        final Instance themultiverse = new Instance(-1);
        themultiverse.setName("multiverse");
        _instancesMap.put(-1, themultiverse);
        _log.info("Multiverse Instance created");
        
        final Instance universe = new Instance(0);
        universe.setName("universe");
        _instancesMap.put(0, universe);
        _log.info("Universe Instance created");
    }
    
    /**
     * Destroys instance by <code>instanceId</code>
     *
     * @param instanceid
     *            id of the instance to destroy
     */
    public void destroyInstance(final int instanceId)
    {
        if (instanceId <= 0)
        {
            return;
        }
        
        final Instance instance = _instancesMap.get(instanceId);
        
        if (instance == null)
        {
            return;
        }
        
        instance.removeNpcs();
        instance.removePlayers();
        instance.removeDoors();
        instance.cancelTimer();
        _instancesMap.remove(instanceId);
        _instanceWorldsMap.remove(instanceId);
    }
    
    /**
     * Searches for instance by <code>instanceId</code>. If instance does not exists, then returns
     * null. This method also logs all attempts for getting non-existant instances so if you just
     * need to check whether instance exists, use {@link #instanceExist(int)} instead.
     *
     * @param instanceId
     *            id of instance
     *
     * @return found instance or null
     */
    public Instance getInstance(final int instanceId)
    {
        final Instance instance = _instancesMap.get(instanceId);
        
        if (instance == null && _log.isLoggable(Level.WARNING))
        {
            _log.log(Level.WARNING, StringUtil.concat("InstanceManager: Instance ", String.valueOf(instanceId), " does not exist in InstanceManager"), new Throwable());
        }
        
        return instance;
    }
    
    /**
     * Checks whether instance of given <code>instanceId</code> exists.
     *
     * @param instanceId
     *            instance id
     *
     * @return true if instance exists, otherwise false
     */
    public boolean instanceExist(final int instanceId)
    {
        return _instancesMap.get(instanceId) != null;
    }
    
    /**
     * Returns map of instance ids and related instances.
     *
     * @return map of instance ids and related instances
     */
    public Map<Integer, Instance> getInstances()
    {
        return _instancesMap;
    }
    
    /**
     * Searches instances to find whether player is specified in any of the instances. Returns first
     * instance that contains this player.
     *
     * @param objectId
     *            player object id
     *
     * @return found instance or zero (default instance)
     */
    public int getPlayerInstance(final int objectId)
    {
        for (final Instance instance : _instancesMap.values())
        {
            if (instance == null)
                continue;
            if (instance.containsPlayer(objectId))
            {
                return instance.getId();
            }
        }
        
        return 0;
    }
    
    /**
     * Creates new instance with dynamic instance id.
     *
     * @param template
     *            path to xml template file or null if instance has no template
     *
     * @return id of the newly created instance
     */
    public int createDynamicInstance(final String template)
    {
        final int newId = _dynamicInstanceId.incrementAndGet();
        
        if (newId == Integer.MAX_VALUE)
        {
            _dynamicInstanceId.set(300000);
            _log.warning(StringUtil.concat("InstanceManager: More then ", String.valueOf(Integer.MAX_VALUE - 300000), " instances created"));
        }
        
        final Instance instance = new Instance(newId);
        _instancesMap.put(newId, instance);
        
        if (template != null)
        {
            try
            {
                instance.loadInstanceTemplate(template);
            }
            catch (final FileNotFoundException e)
            {
                _log.log(Level.WARNING, StringUtil.concat("InstanceManager: Failed creating instance from " + "template ", template), e);
            }
        }
        
        return newId;
    }
    
    /**
     * Creates new instance using specified instance id. Only values between 1 and 299,999 can be
     * used.
     *
     * @param instanceId
     *            instance id
     *
     * @return true if instance was created, otherwise false
     */
    public boolean createInstance(final int instanceId)
    {
        if (instanceId <= 0 || instanceId >= 300000 || instanceExist(instanceId))
        {
            return false;
        }
        
        final Instance instance = new Instance(instanceId);
        _instancesMap.put(instanceId, instance);
        
        return true;
    }
    
    /**
     * Creates new instance using specified instance id. Only values between 1 and 299,999 can be
     * used.
     *
     * @param instanceId
     *            instance id
     * @param template
     *            path to xml template file
     *
     * @return true if instance was created, otherwise false
     *
     * @throws FileNotFoundException
     *             Thrown if problem occured while trying to read template file.
     */
    public boolean createInstanceFromTemplate(final int instanceId, final String template) throws FileNotFoundException
    {
        if (instanceId <= 0 || instanceId >= 300000 || instanceExist(instanceId))
        {
            return false;
        }
        
        final Instance instance = new Instance(instanceId);
        _instancesMap.put(instanceId, instance);
        instance.loadInstanceTemplate(template);
        
        return true;
    }
    
    /**
     * @param playerInstanceTimes the playerInstanceTimes to set
     */
    public void setPlayerInstanceTimes(Map<Integer, Map<Integer, Long>> playerInstanceTimes)
    {
        _playerInstanceTimes = playerInstanceTimes;
    }
    
    /**
     * @return the playerInstanceTimes
     */
    public Map<Integer, Map<Integer, Long>> getPlayerInstanceTimes()
    {
        return _playerInstanceTimes;
    }
    
    /**
     * Instance world information.
     */
    public class InstanceWorld
    {
        
        /**
         * Id of related instance.
         */
        public int instanceId;
        /**
         * TemplateId of related instance.
         */
        public int templateId = -1;
        /**
         * Collection of players that are allowed to enter the instance.
         */
        public Set<Integer> allowed = new CopyOnWriteArraySet<Integer>();
        /**
         * Status of instance world. The meaning of values is specific to each instance.
         */
        public int status;
    }
    
    /**
     * Singleton holder for InstanceManager instance.
     */
    @SuppressWarnings("synthetic-access")
    private static class SingletonHolder
    {
        
        /**
         * The single instance of InstanceManager.
         */
        protected static final InstanceManager INSTANCE = new InstanceManager();
    }
}

Добавлено через 1 минуту
не беспокойтесь импорты я заменил правильно, просто скопировал первый пост из сборки

Добавлено через 11 минут
мб нада заменить на valueOf ?)

[VISTALL]

world.allowed.remove(player.getObjectId())

вот так и все

там поменяли List -> Set в листе нету индексов