/** * Creates an account for a player in the game. * * @param username player's username * @param password player's password * @param email player's email * @param address ip address of client * @return a Result indicating if account creation was done successfully or not. */ public AccountResult createAccount( String username, String password, String email, String address) { try { if (!Boolean.parseBoolean( Configuration.getConfiguration().get("allow_account_creation", "true"))) { return new AccountResult(Result.FAILED_CREATE_ON_MAIN_INSTEAD, username); } } catch (IOException e) { logger.error(e, e); } // check account creation limits try { if (DAORegister.get().get(AccountDAO.class).isAccountCreationLimitReached(address)) { return new AccountResult(Result.FAILED_TOO_MANY, username); } } catch (SQLException e) { logger.error(e, e); return new AccountResult(Result.FAILED_EXCEPTION, username); } catch (IOException e) { logger.error(e, e); return new AccountResult(Result.FAILED_EXCEPTION, username); } // forward the creation request to the game return ruleProcessor.createAccount(username, password, email); }
/** * Creates a character for a account of a player * * @param username player's username * @param character * @param template the template we are going to use to create the object. * @param address ip address of client * @return a Result indicating if account creation was done successfully or if it is not the * cause. */ public CharacterResult createCharacter( String username, String character, RPObject template, String address) { try { if (!Boolean.parseBoolean( Configuration.getConfiguration().get("allow_account_creation", "true"))) { return new CharacterResult(Result.FAILED_CREATE_ON_MAIN_INSTEAD, character, template); } } catch (IOException e) { logger.error(e, e); } // check account creation limits try { if (DAORegister.get() .get(CharacterDAO.class) .isCharacterCreationLimitReached(username, address)) { return new CharacterResult(Result.FAILED_TOO_MANY, character, template); } } catch (SQLException e) { logger.error(e, e); return new CharacterResult(Result.FAILED_EXCEPTION, character, template); } catch (IOException e) { logger.error(e, e); return new CharacterResult(Result.FAILED_EXCEPTION, character, template); } return ruleProcessor.createCharacter(username, character, template); }
/** * reads a file into a map * * @param is InputStream * @param resultMap content is store in this map */ private static void readFile(InputStream is, Map<String, String> resultMap) { BufferedReader reader = null; try { reader = new BufferedReader(new InputStreamReader(is, "UTF-8")); String line = reader.readLine(); while (line != null) { int pos = line.indexOf("="); if (pos > -1) { String key = line.substring(0, pos); String value = line.substring(pos + 1); resultMap.put(key, value); } line = reader.readLine(); } } catch (IOException e) { logger.error(e, e); } if (reader != null) { try { reader.close(); } catch (IOException e) { logger.error(e, e); } } }
private void sendPlayerPerception( PlayerEntry entry, Perception perception, RPObject playerObject) { if (perception == null) { /** Until player enters game perception is null */ return; } MessageS2CPerception messages2cPerception = new MessageS2CPerception(entry.channel, perception); stats.add("Perceptions " + (perception.type == 0 ? "DELTA" : "SYNC"), 1); /* * The perception is build of two parts: the general information and the * private information about our object. This private information * consists only of attributes that are not visible to every player but * the owner, because visible attributes are already stored in the * perception. */ if (perception.type == Perception.SYNC) { RPObject copy = new RPObject(); copy.fill(playerObject); if (!playerObject.isHidden()) { copy.clearVisible(true); } messages2cPerception.setMyRPObject(copy, null); } else { RPObject added = new RPObject(); RPObject deleted = new RPObject(); try { playerObject.getDifferences(added, deleted); if (!playerObject.isHidden()) { added.clearVisible(false); deleted.clearVisible(false); } if (added.size() == 0) { added = null; } if (deleted.size() == 0) { deleted = null; } } catch (Exception e) { logger.error("Error getting object differences", e); logger.error(playerObject); added = null; deleted = null; } messages2cPerception.setMyRPObject(added, deleted); } messages2cPerception.setClientID(entry.clientid); messages2cPerception.setPerceptionTimestamp(entry.getPerceptionTimestamp()); messages2cPerception.setProtocolVersion(entry.getProtocolVersion()); netMan.sendMessage(messages2cPerception); }
private void buildPerceptions() { playersToRemove.clear(); /** We reset the cache at Perceptions */ MessageS2CPerception.clearPrecomputedPerception(); for (PlayerEntry entry : playerContainer) { try { // Before creating the perception we check the player is still there. if (entry.isTimeout()) { logger.info("Request (TIMEOUT) disconnection of Player " + entry.getAddress()); playersToRemove.add(entry); continue; } if (entry.state == ClientState.GAME_BEGIN) { Perception perception = getPlayerPerception(entry); sendPlayerPerception(entry, perception, entry.object); } } catch (Exception e) { logger.error( "Removing player(" + entry.clientid + ") because it caused a Exception while contacting it", e); playersToRemove.add(entry); } } for (PlayerEntry entry : playersToRemove) { logger.warn("RP Disconnecting entry: " + entry); netMan.disconnectClient(entry.channel); } }
/** * This method finishes the thread that runs the RPServerManager. It calls the RPWorld.onFinish() * method. */ public void finish() { keepRunning = false; while (!isfinished) { Thread.yield(); } try { world.onFinish(); } catch (Exception e) { logger.error("error while finishing RPServerManager", e); } }
/** * counts the number of connections from this ip-address * * @param playerContainer PlayerEntryContainer * @return number of active connections */ public int countConnectionsFromSameIPAddress(PlayerEntryContainer playerContainer) { if (address == null) { return 0; } int counter = 0; for (PlayerEntry playerEntry : playerContainer) { try { if ((playerEntry.getAddress() != null) && address.getHostAddress().equals(playerEntry.getAddress().getHostAddress())) { counter++; } } catch (NullPointerException e) { logger.error(address); logger.error(address.getHostAddress()); logger.error(playerEntry); logger.error(playerEntry); logger.error(playerEntry.getAddress()); logger.error(e, e); } } return counter; }
@Override public void readObject(marauroa.common.net.InputSerializer in) throws IOException { super.readObject(in); try { reason = Result.values()[in.readByte()]; } catch (ArrayIndexOutOfBoundsException e) { logger.error(e, e); reason = Result.FAILED_EXCEPTION; } if (type != MessageType.S2C_CREATEACCOUNT_NACK) { throw new IOException(); } }
private void savePlayersPeriodicly() { for (PlayerEntry entry : playerContainer) { try { // do not use = 0 because we need a little time until the // player object is fully initialized (e. g. has a charname) if (entry.getThisPerceptionTimestamp() % 2000 == 1999) { entry.storeRPObject(entry.object); } } catch (Exception e) { String name = "null"; if (entry != null) { name = entry.character; } logger.error("Error while storing player " + name, e); } } }
/** * Add a login event to database each time player login, even if it fails. * * @param transaction DBTransactions * @param address the IP address that originated the request. * @param result 0 failed password, 1 successful login, 2 banned, 3 inactive, 4 blocked, 5 merged * @throws SQLException if there is any database problem. */ public void addLoginEvent(DBTransaction transaction, InetAddress address, int result) throws SQLException { String service = null; try { Configuration conf = Configuration.getConfiguration(); if (conf.has("server_service")) { service = conf.get("server_service"); } else { service = conf.get("server_typeGame"); } } catch (IOException e) { logger.error(e, e); } DAORegister.get() .get(LoginEventDAO.class) .addLoginEvent(transaction, username, address, service, seed, result); }
@Override public void run() { try { long start = System.nanoTime(); long stop; long delay; long timeStart = 0; long[] timeEnds = new long[12]; while (keepRunning) { stop = System.nanoTime(); logger.debug("Turn time elapsed: " + ((stop - start) / 1000) + " microsecs"); delay = turnDuration - ((stop - start) / 1000000); if (delay < 0) { StringBuilder sb = new StringBuilder(); for (long timeEnd : timeEnds) { sb.append(" " + (timeEnd - timeStart)); } logger.warn("Turn duration overflow by " + (-delay) + " ms: " + sb.toString()); } else if (delay > turnDuration) { logger.error( "Delay bigger than Turn duration. [delay: " + delay + "] [turnDuration:" + turnDuration + "]"); delay = 0; } // only sleep when the turn delay is > 0 if (delay > 0) { try { Thread.sleep(delay); } catch (InterruptedException e) { // ignore } } start = System.nanoTime(); timeStart = System.currentTimeMillis(); playerContainer.getLock().requestWriteLock(); try { timeEnds[0] = System.currentTimeMillis(); /* Get actions that players send */ scheduler.nextTurn(); timeEnds[1] = System.currentTimeMillis(); /* Execute them all */ scheduler.visit(ruleProcessor); timeEnds[2] = System.currentTimeMillis(); /* Compute game RP rules to move to the next turn */ ruleProcessor.endTurn(); timeEnds[3] = System.currentTimeMillis(); /* Send content that is waiting to players */ deliverTransferContent(); timeEnds[4] = System.currentTimeMillis(); /* Tell player what happened */ buildPerceptions(); timeEnds[5] = System.currentTimeMillis(); /* save players regularly to the db */ savePlayersPeriodicly(); timeEnds[6] = System.currentTimeMillis(); /* Move zone to the next turn */ world.nextTurn(); timeEnds[7] = System.currentTimeMillis(); turn++; ruleProcessor.beginTurn(); timeEnds[8] = System.currentTimeMillis(); } finally { playerContainer.getLock().releaseLock(); timeEnds[9] = System.currentTimeMillis(); } try { stats.set("Objects now", world.size()); } catch (ConcurrentModificationException e) { // TODO: size is obviously not threadsafe as it asks the underlying zone.objects for its // sizes, which are not threadsafe. } timeEnds[10] = System.currentTimeMillis(); TransactionPool.get().kickHangingTransactionsOfThisThread(); timeEnds[11] = System.currentTimeMillis(); } } catch (Throwable e) { logger.error("Unhandled exception, server will shut down.", e); } finally { isfinished = true; } }