Java HostedConnection.getAttribute方法代码示例

import com.jme3.network.HostedConnection; //导入方法依赖的package包/类
public static HostedConnection getSource(int playerId) {
    Collection<HostedConnection> connections = Globals.app.getStateManager()
            .getState(ServerSender.class).getServer().getConnections();

    for (HostedConnection hostedConnection : connections) {
        // FIXME: NullPointerException may happen here when player joins!
        if (hostedConnection.getAttribute(
                ServerClientDataStrings.PLAYER_ID) == null) {
            logger.log(Level.WARNING, "PlayerId of connection {0} is null!", 
                    hostedConnection.getId());
            continue;
        }
        if (hostedConnection.getAttribute(ServerClientDataStrings.PLAYER_ID)
                .equals(playerId)) {
            return hostedConnection;
        }
    }

    return null;
}
 

import com.jme3.network.HostedConnection; //导入方法依赖的package包/类
@Override
protected void onClientRemoved(GameServer gameServer, HostedConnection conn) {
    super.onClientRemoved(gameServer, conn); 
    ConnData cd = conn.getAttribute(ConnData.CONN_ATTRIBUTE_KEY);
    if (cd == null)
        return;

    Entity clientPlayer = playService.getEntity(cd.getEntityId());
    if (clientPlayer == null)
        return;
    
    // 1.将客户端角色的所有宠物移除出场景,注意是宠物，不要把非生命的（如防御塔）也一起移除
    List<Entity> actors = playService.getEntities(Entity.class, null);
    if (actors != null && !actors.isEmpty()) {
        for (Entity actor : actors) {
            if (gameService.getOwner(actor) == clientPlayer.getData().getUniqueId() && gameService.isBiology(actor)) {
                playNetwork.removeEntity(actor);
            }
        }
    }

    // 2.将客户端角色移除出场景
    playNetwork.removeEntity(clientPlayer);

    // 3.通知所有客户端（不含主机）
    String message = ResManager.get(ResConstants.LAN_CLIENT_EXISTS, new Object[] {gameService.getName(clientPlayer)});
    MessageMess notice = new MessageMess();
    notice.setMessage(message);
    notice.setType(MessageType.notice);
    gameServer.broadcast(notice);

    // 4.通知主机
    addMessage(message, MessageType.notice);
}
 

import com.jme3.network.HostedConnection; //导入方法依赖的package包/类
@Override
public void kickClient(int connId) {
    // 踢出之前先把玩家的资料保存起来
    HostedConnection conn = gameServer.getServer().getConnection(connId);
    if (conn != null) {
        ConnData cd = conn.getAttribute(ConnData.CONN_ATTRIBUTE_KEY);
        if (cd != null && cd.getClientId() != null && cd.getEntityId() > 0) {
            storeClient(saveStory, scene.getEntities(Actor.class, null), cd.getClientId(), cd.getEntityId(), data.getId());
            SaveHelper.saveStoryLast(saveStory);
        }
    }
    super.kickClient(connId);
}
 

import com.jme3.network.HostedConnection; //导入方法依赖的package包/类
/**
 * 保存整个存档，当故事模式在退出时要保存整个存档，包含主角，其它客户端玩家资料，及所有玩家的宠物等。
 */
private void saveStory() {
    String gameId = data.getId();
    List<Actor> actors = scene.getEntities(Actor.class, null);
    
    // 保存所有故事模式下的主角
    Entity savePlayer = getPlayer();
    savePlayer.updateDatas();
    storeClient(saveStory, actors, configService.getClientId(), savePlayer.getEntityId(), gameId);
    
    // 保存当前所有客户端的资料
    Collection<HostedConnection> conns = gameServer.getServer().getConnections();
    if (conns != null && conns.size() > 0) {
        for (HostedConnection hc : conns) {
            ConnData cd = hc.getAttribute(ConnData.CONN_ATTRIBUTE_KEY);
            // 如果客户端刚刚连接或还没有选角色
            if (cd.getClientId() == null || cd.getEntityId() <= 0)
                continue;
            storeClient(saveStory, actors, cd.getClientId(), cd.getEntityId(), gameId);
        }
    }
    
    // 单独保存主角，这是为了兼容v2.4及之前的版本,后续可能会取消这个特殊的保存方式.
    saveStory.setPlayer(savePlayer.getData());
    
    // 保存快捷方式
    saveStory.setShortcuts(ShortcutManager.getShortcutSaves());
    
    // 存档到系统文件 
    SaveHelper.saveStoryLast(saveStory);

    // 保存全局配置
    gameService.saveConfig(LyConfig.getConfigData());
}
 

import com.jme3.network.HostedConnection; //导入方法依赖的package包/类
/**
 * 当前客户端获得标识时,这一步发生在 {@link #onClientAdd }之后, 主要更
 * 新客户端的标识，并刷新客户端列表。
 * @param gameServer
 * @param conn
 * @param m 
 */
protected void onReceiveMessClient(GameServer gameServer, HostedConnection conn, ClientMess m) {
    // 登记、更新客户端资料
    ConnData cd = conn.getAttribute(ConnData.CONN_ATTRIBUTE_KEY);
    cd.setClientId(m.getClientId());
    cd.setClientName(m.getClientName());
    // 更新客户端列表
    onClientsUpdated(gameServer);
}
 

import com.jme3.network.HostedConnection; //导入方法依赖的package包/类
/**
 * 当一个新的客户端连接到服务端时该方法被自动调用，默认情况下，
 * 该方法将立即向客户端发送游戏数据{@link GameData}作为响应.
 * 注：默认情况下，服务端只向客户端发送游戏的基本数据,不包含场景数据及游戏逻辑。
 * @param gameServer
 * @param conn 
 * @see #onSendGameData(GameServer, HostedConnection) 
 */
protected void onClientAdded(GameServer gameServer, HostedConnection conn) {
    // 初始化一个用于存放数据的容器,选择在这里初始化以便后续使用的时候不再需要判断null
    ConnData cd = conn.getAttribute(ConnData.CONN_ATTRIBUTE_KEY);
    if (cd == null) {
        cd = new ConnData();
        cd.setConnId(conn.getId());
        cd.setAddress(conn.getAddress());
        conn.setAttribute(ConnData.CONN_ATTRIBUTE_KEY, cd);
    }
    // 当客户端连接时向客户端发送游戏数据
    onSendGameData(gameServer, conn);
    // 更新客户端列表
    onClientsUpdated(gameServer);
}
 

import com.jme3.network.HostedConnection; //导入方法依赖的package包/类
/**
 * xxx 这个方法要移动到其它地方:AbstractServerListener。
 * 获取当前已经连接的所有客户端,其中包含主机
 * @return 
 */
public List<ConnData> getClients() {
    // 需要判断游戏是否在运行,在游戏运行时可以获取到玩家角色名字
    boolean gameInPlay = playService.getGame() != null;
    
    // 向客户端广播，告诉所有客户端有新的客户端连接进来，并把客户端列表
    // 发送给所有已经连接的客户端
    Collection<HostedConnection> hcs = server.getConnections();
    List<ConnData> clients = new ArrayList<ConnData>();
    
    for (HostedConnection hc : hcs) {
        ConnData cd = hc.getAttribute(ConnData.CONN_ATTRIBUTE_KEY);
        clients.add(cd);
    }
    
    // 添加主机信息到客户端列表中,注：在没有网络的情况下getLocalHostIPv4可能会返回null,这时需要判断处理
    InetAddress inetAddress = envService.getLocalHostIPv4();
    String serverAddress = inetAddress != null ? inetAddress.getHostAddress() : "0.0.0.0";
    String serverMachineName = envService.getMachineName();
    ConnData serverConnData = new ConnData();
    serverConnData.setClientId(configService.getClientId());
    serverConnData.setClientName(serverMachineName);
    serverConnData.setConnId(-1);
    serverConnData.setAddress(serverAddress);
    if (gameInPlay) {
        // xxx 重构
        serverConnData.setEntityId(-1);
        serverConnData.setEntityName("--");
    }
    clients.add(0, serverConnData);
    return clients;
}
 

import com.jme3.network.HostedConnection; //导入方法依赖的package包/类
@Override
    public void applyOnServer(GameServer gameServer, HostedConnection source) {
        // remove20161102,暂不进行安全判断
//        PlayService playService = Factory.get(PlayService.class);
//        ActorService actorService = Factory.get(ActorService.class);
//        SkinNetwork skinNetwork = Factory.get(SkinNetwork.class);
//        Entity actor = playService.getEntity(actorId);
//        if (actor == null) {
//            return; // 找不到指定的角色
//        }
//        ConnData cd = source.getAttribute(ConnData.CONN_ATTRIBUTE_KEY);
//        long clientActorId = cd != null ? cd.getEntityId() : -1;
//        // 使用物品的必须是客户端角色自身或者客户端角色的宠物
//        if (actor.getData().getUniqueId() == clientActorId
//                || actorService.getOwner(actor) == clientActorId) {
//            if (takeOn) {
//                skinNetwork.takeOnWeapon(actor);
//            } else {
//                skinNetwork.takeOffWeapon(actor);
//            }
//        }

        Entity actor = Factory.get(PlayService.class).getEntity(actorId);
        if (actor == null) {
            return; // 找不到指定的角色
        }
        ConnData cd = source.getAttribute(ConnData.CONN_ATTRIBUTE_KEY);
//        long clientActorId = cd != null ? cd.getEntityId() : -1;
        if (takeOn) {
            Factory.get(SkinNetwork.class).takeOnWeapon(actor);
        } else {
            Factory.get(SkinNetwork.class).takeOffWeapon(actor);
        }
    }
 

import com.jme3.network.HostedConnection; //导入方法依赖的package包/类
@Override
public void applyOnServer(GameServer gameServer, HostedConnection source) {
    super.applyOnServer(gameServer, source);
    PlayService playService = Factory.get(PlayService.class);
    PlayNetwork playNetwork = Factory.get(PlayNetwork.class);
    
    ConnData cd = source.getAttribute(ConnData.CONN_ATTRIBUTE_KEY);
    Long actorId = cd != null ? cd.getEntityId() : null;
    
    Entity actor = playService.getEntity(actorId);
    Entity target = playService.getEntity(targetId);
    playNetwork.attack(actor, target);
}
 

import com.jme3.network.HostedConnection; //导入方法依赖的package包/类
private void serverReadGuaranteed(HostedConnection source,
        Command command) {
    if (command instanceof CmdSelectHero) {
        int playerId =
                source.getAttribute(ServerClientDataStrings.PLAYER_ID);
        common.playerChoseHero(playerId,
                ((CmdSelectHero) command).getHeroName());
        stateManager.getState(ServerSender.class)
                .addCommandForSingle(command, source);
    } else if (command instanceof CmdTopicOnly) {
        common.serverHandleTopicOnlyCommand(source, (CmdTopicOnly) command);
    }
}
 

import com.jme3.network.HostedConnection; //导入方法依赖的package包/类
private void saveCommand(Command command, HostedConnection connection) {
    if (command instanceof Ack) {
        return;
    }

    Integer playerId
            = connection.getAttribute(ServerClientDataStrings.PLAYER_ID);

    if (playerId == null) {
        return;
    }

    replayData.addCommand(command, playerId, world.getWorldTime());
}
 

import com.jme3.network.HostedConnection; //导入方法依赖的package包/类
@Override
    public void applyOnServer(GameServer gameServer, HostedConnection source) {
        super.applyOnServer(gameServer, source);
        
        // remove20161121
//        PlayService playService = Factory.get(PlayService.class);
//        ActorNetwork actorNetwork = Factory.get(ActorNetwork.class);
//        ActionService actionService = Factory.get(ActionService.class);
//        
//        Entity actor = (Actor) playService.getEntity(actorId);
//        if (actor == null) 
//            return;
//
//        ConnData cd = source.getAttribute(ConnData.CONN_ATTRIBUTE_KEY);
//        Long uniqueActorId = cd != null ? cd.getEntityId() : null;
//        
//        if (uniqueActorId != actor.getData().getUniqueId()) {
//            return; // 不允许控制别人的角色
//        }
//        
//        // remove20151229服务端以后一直打开AI
////        actorService.setAutoAi(actor, false);
//   
//        // remove20161103
////        // 必须清除跟随
////        actorNetwork.setFollow(actor, -1);
//        
//        // 走向目标,action不需要广播
//        actionService.playRun(actor, pos);

        // 角色必须存在
        Entity actor = (Actor) Factory.get(PlayService.class).getEntity(actorId);
        if (actor == null) 
            return;

        // 不允许控制别人的角色
        ConnData cd = source.getAttribute(ConnData.CONN_ATTRIBUTE_KEY);
        long uniqueActorId = cd != null ? cd.getEntityId() : -1;
        if (uniqueActorId != actor.getData().getUniqueId()) {
            return; 
        }
        
        // 走向目标,action不需要广播
        GameNetwork gameNetwork = Factory.get(GameNetwork.class);
        gameNetwork.playRunToPos(actor, pos);
    }
 

import com.jme3.network.HostedConnection; //导入方法依赖的package包/类
/**
 * 处理来自服务端的肖息
 * @param gameServer
 * @param source
 * @param m
 */
protected void processGameMess(GameServer gameServer, HostedConnection source, GameMess m) {
    // 客户端告诉服务端，要选择哪一个角色进行游戏.
    // 在必要时可以对接收到的ActorSelectMess进行一些验证,比如确保选择的角色数据没有异常。
    // 名称不会重复等。
    if (m instanceof ActorSelectMess) {

        // 选择玩家角色
        ActorSelectMess mess = (ActorSelectMess) m;
        Entity actor = Loader.load(mess.getEntityData());

        // 默认情况下，不管是在Story模式或是在Lan模式，玩家选择后的角色都为1级.但是在某些情况下会有一些不同，比如：
        // 1.在Lan模式下玩家的初始属性可能会受Game逻辑的影响.参考：gameState.getGame().onPlayerSelected(actor);
        // 2.在Story模式下，如果客户端的资料已经存档在服务端，则连接时直接使用存档进行游戏，而不需要重新选择角色。
        gameService.setLevel(actor, 1);
        
        // 记住客户端所选择的角色,要放在addPlayer之前，因为在gameServer.broadcast(new MessSCClientList(gameServer.getClients()));
        // 之前要先更新ConnData,否则gameServer.getClients()获取不到实时的角色资料更新
        ConnData cd = source.getAttribute(ConnData.CONN_ATTRIBUTE_KEY);
        cd.setEntityId(actor.getData().getUniqueId());
        cd.setEntityName(gameService.getName(actor));
        
        // 添加到场景
        onAddClientPlayer(cd, actor);
        
        // 返回消息给客户端，让客户端知道所选择的角色成功。
        ActorSelectResultMess result = new ActorSelectResultMess();
        result.setActorId(actor.getData().getUniqueId());
        result.setSuccess(true);
        gameServer.send(source, result);
        
        return;
    } 

    // 当服务端接收到客户端退出游戏的消息时，这里什么也不处理。与故事模式不同。故事模式要保存客户端资料.
    // 服务端暂时不需要处理任何逻辑
    if (m instanceof ClientExitMess) {
        return;
    }
    
    m.applyOnServer(gameServer, source);
}