@Test
public void getNumberOfPlayersShouldReturnTotalNumberOfHumanPlayers() {
when(mockGameFactory.create(1, 0, true, false, null, true, GameMode.EVENT))
.thenReturn(mockGame1);
when(mockGame1.getNumberOfHumanPlayer()).thenReturn(1);
when(mockGameFactory.create(2, 0, true, false, null, false, GameMode.EVENT))
.thenReturn(mockGame2);
when(mockGame2.getNumberOfHumanPlayer()).thenReturn(2);
gameManager.getOrCreateMatchingSession(
GameMode.EVENT,
"public EVENT name",
0,
null,
EnumSet.of(ProblemGenre.Anige),
EnumSet.of(ProblemType.Marubatsu),
true,
mockServerStatusManager,
12345678,
"192.168.0.1");
gameManager.getOrCreateMatchingSession(
GameMode.EVENT,
"closed EVENT name",
0,
null,
EnumSet.of(ProblemGenre.Anige),
EnumSet.of(ProblemType.Marubatsu),
false,
mockServerStatusManager,
12345678,
"192.168.0.1");
assertEquals(3, gameManager.getNumberOfPlayers());
}
public static Entity makePlayerControlled(Entity entity) {
entity.add(GameManager.getGame().engine.createComponent(PlayerOwnedComponent.class));
entity.add(GameManager.getGame().engine.createComponent(PlayerControllerComponent.class));
entity.add(GameManager.getGame().engine.createComponent(JoystickControllerComponent.class));
return entity;
}
public static Entity createMap() {
Entity map = GameManager.getGame().engine.createEntity();
MapComponent mapComponent = GameManager.getGame().engine.createComponent(MapComponent.class);
mapComponent.init(256, 256);
mapComponent.rectangle.x = -128;
mapComponent.rectangle.y = -128;
map.add(mapComponent);
GameManager.getGame().engine.addEntity(map);
return map;
}
public static Entity createPlayer(float x, float y, float width, float height) {
Entity entity = createBasicMovingEntity(x, y, width, height);
makePlayerControlled(entity);
makeVisual(entity, width, height, "player_ship1.png");
entity.add(GameManager.getGame().engine.createComponent(ShootingComponent.class));
entity.add(GameManager.getGame().engine.createComponent(CameraFocusComponent.class));
GameManager.getGame().engine.addEntity(entity);
return entity;
}
public static Entity createBullet(float x, float y, float width, float height) {
Entity bullet = createBasicMovingEntity(x, y, width, height);
makeVisual(bullet, width, height, null);
bullet.add(GameManager.getGame().engine.createComponent(DamageOnCollisionComponent.class));
//
// bullet.add(GameManager.getGame().engine.createComponent(DestroyOnMapCollisionComponent.class));
GameManager.getGame().engine.addEntity(bullet);
return bullet;
}
public void run() {
datafolder = p.getDataFolder();
PluginManager pm = getServer().getPluginManager();
setCommands();
SettingsManager.getInstance().setup(p);
MessageManager.getInstance().setup();
GameManager.getInstance().setup(p);
try { // try loading everything that uses SQL.
FileConfiguration c = SettingsManager.getInstance().getConfig();
if (c.getBoolean("stats.enabled")) DatabaseManager.getInstance().setup(p);
QueueManager.getInstance().setup();
StatsManager.getInstance().setup(p, c.getBoolean("stats.enabled"));
dbcon = true;
} catch (Exception e) {
dbcon = false;
e.printStackTrace();
logger.severe(
"!!!Failed to connect to the database. Please check the settings and try again!!!");
return;
} finally {
LobbyManager.getInstance().setup(p);
}
ChestRatioStorage.getInstance().setup();
HookManager.getInstance().setup();
pm.registerEvents(new PlaceEvent(), p);
pm.registerEvents(new BreakEvent(), p);
pm.registerEvents(new DeathEvent(), p);
pm.registerEvents(new MoveEvent(), p);
pm.registerEvents(new CommandCatch(), p);
pm.registerEvents(new SignClickEvent(), p);
pm.registerEvents(new ChestReplaceEvent(), p);
pm.registerEvents(new LogoutEvent(), p);
pm.registerEvents(new JoinEvent(p), p);
pm.registerEvents(new TeleportEvent(), p);
pm.registerEvents(LoggingManager.getInstance(), p);
pm.registerEvents(new SpectatorEvents(), p);
pm.registerEvents(new BandageUse(), p);
pm.registerEvents(new KitEvents(), p);
for (Player p : Bukkit.getOnlinePlayers()) {
if (GameManager.getInstance().getBlockGameId(p.getLocation()) != -1) {
p.teleport(SettingsManager.getInstance().getLobbySpawn());
}
}
// new Webserver().start();
}
public void configureGL(GL2 gl) {
gl.glEnable(GL2.GL_FOG);
gl.glFogi(GL2.GL_FOG_MODE, GL2.GL_LINEAR);
gl.glFogf(GL2.GL_FOG_DENSITY, 0.25f);
gl.glFogf(GL2.GL_FOG_START, Math.max(getNearClippingPlane(), fadeOut * 1.0f));
gl.glFogf(GL2.GL_FOG_END, Math.max(1.1f, fadeOut * 1.1f * getSpawnDistance()));
gl.glMatrixMode(GL2.GL_PROJECTION);
gl.glLoadIdentity();
gl.glFrustumf(-1, 1, -man.vheight(), man.vheight(), getNearClippingPlane(), 128.0f);
gl.glScalef(2.0f, 2.0f, 1);
gl.glTranslatef(-0.5f, -man.vheight() / 2.0f, 0);
gl.glMatrixMode(GL2.GL_MODELVIEW);
gl.glLoadIdentity();
}
/** Usage: java ...Tunnelblick [sensitivity=1.0 [useopenni=false]] */
public static void main(String[] argv) {
float sensitivity = 1.0f;
boolean withOpenNi = false;
if (argv.length >= 1) sensitivity = Float.valueOf(argv[0]).floatValue();
if (argv.length >= 2) withOpenNi = Boolean.valueOf(argv[1]);
OpenNiBodyTrackerInputDriver onbtid =
withOpenNi ? new OpenNiBodyTrackerInputDriver(true) : null;
GameManager man = new GameManager("Tunnelblick", 800, 600);
KeyboardGestureInputDriver kgid = new KeyboardGestureInputDriver();
kgid.bind(java.awt.event.KeyEvent.VK_SPACE, InputEvent.GESTURE_JUMP);
man.installInputDriver(kgid);
MouseButtonGestureInputDriver mbgid = new MouseButtonGestureInputDriver();
mbgid.bind(java.awt.event.MouseEvent.BUTTON1, InputEvent.GESTURE_JUMP);
man.installInputDriver(mbgid);
ModalMouseMotionInputDriver mmmid = new ModalMouseMotionInputDriver();
mmmid.setPointerMode(false);
man.installInputDriver(mmmid);
if (withOpenNi) man.installInputDriver(onbtid);
Tunnelblick state = new Tunnelblick(man);
state.getPlayer().setSensitivity(sensitivity);
man.setState(state);
man.run();
man.destroy();
}
public void setLobbySignsFromSelection(Player pl, int a) {
FileConfiguration c = SettingsManager.getInstance().getSystemConfig();
SettingsManager s = SettingsManager.getInstance();
if (!c.getBoolean("walls-system.lobby.sign.set", false)) {
c.set("walls-system.lobby.sign.set", true);
s.saveSystemConfig();
}
WorldEditPlugin we = GameManager.getInstance().getWorldEdit();
Selection sel = we.getSelection(pl);
if (sel == null) {
pl.sendMessage(ChatColor.RED + "You must make a WorldEdit Selection first");
return;
}
if ((sel.getNativeMaximumPoint().getBlockX() - sel.getNativeMinimumPoint().getBlockX()) != 0
&& (sel.getNativeMinimumPoint().getBlockZ() - sel.getNativeMaximumPoint().getBlockZ()
!= 0)) {
pl.sendMessage(ChatColor.RED + " Must be in a straight line!");
return;
}
Vector max = sel.getNativeMaximumPoint();
Vector min = sel.getNativeMinimumPoint();
int i = c.getInt("walls-system.lobby.signno", 0) + 1;
c.set("walls-system.lobby.signno", i);
c.set("walls-system.lobby.signs." + i + ".id", a);
c.set("walls-system.lobby.signs." + i + ".world", pl.getWorld().getName());
c.set("walls-system.lobby.signs." + i + ".x1", max.getBlockX());
c.set("walls-system.lobby.signs." + i + ".y1", max.getBlockY());
c.set("walls-system.lobby.signs." + i + ".z1", max.getBlockZ());
c.set("walls-system.lobby.signs." + i + ".x2", min.getBlockX());
c.set("walls-system.lobby.signs." + i + ".y2", min.getBlockY());
c.set("walls-system.lobby.signs." + i + ".z2", min.getBlockZ());
pl.sendMessage(ChatColor.GREEN + "Added Lobby Wall"); // TODO
s.saveSystemConfig();
loadSign(i);
}
public static Entity makeHoming(Entity entity, Entity homingTarget) {
HomingComponent homing = GameManager.getGame().engine.createComponent(HomingComponent.class);
homing.target = homingTarget;
entity.add(homing);
return entity;
}
@Test
public void getOrCreateMatchingSessionShouldReturnSameMatchingGameSessionForSecondTime() {
when(mockGameFactory.create(1, 0, false, false, null, false, GameMode.WHOLE))
.thenReturn(mockGame1);
when(mockGame1.getTransition()).thenReturn(Transition.Matching);
List<Game> games = Lists.newArrayList();
for (int i = 0; i < 2; ++i) {
Game game =
gameManager.getOrCreateMatchingSession(
GameMode.WHOLE,
null,
0,
null,
EnumSet.of(ProblemGenre.Anige),
EnumSet.of(ProblemType.Marubatsu),
false,
mockServerStatusManager,
12345678,
"192.168.0.1");
games.add(game);
}
assertEquals(ImmutableList.of(mockGame1, mockGame1), games);
}
public Tunnelblick(GameManager man) {
this.man = man;
player = new Player(this);
field.add(player);
music = new MusicPlayer(distortion);
man.getAudioPlayer().addSource(music, (short) 0x7FFF);
}
void stopTimer() {
if (mGameManager != null && mTimer != null) {
mGameManager.stopTimer();
mTimer.cancel();
mTimer = null;
}
}
private Image getImageOfPlayerImpl(Player player) {
String key;
GameManager<Container> gm = getGameManager();
Flag flag = gm.getFlagOf(player);
switch (flag) {
case PLAYER_ONE:
key = Keywords.IMAGE_PLAYER_ONE;
break;
case PLAYER_TWO:
key = Keywords.IMAGE_PLAYER_TWO;
break;
default:
throw new IllegalArgumentException("cannot resolve flag: " + flag);
}
return (Image) gm.<Image>getResource(key, Image.class);
}
public void changeBallType(Ball.BallType type) {
if (gameManager.hasItem(type)) {
LevelScreen screen = levelScreenManager.getScreen();
BallShooter shooter = screen.getShooter();
shooter.changeBallType(type);
undo = true;
}
}
public LeaderboardScreen(Component comp, Graphics2D g2d, GameManager context) {
this.component = comp;
this.g2d = g2d;
this.context = context;
background = new ImageEntity(comp, g2d);
background.load("/resources/leaderboardBackground.png");
leaderboard = context.getLeaderboard();
}
@Override
protected void onResume() {
super.onResume();
if (mGameManager != null) {
updateMineFlagsRemainingCount(mGameManager.getMineFlagsRemainingCount());
startTimer();
}
}
private void initState() {
states = new GameState[Constant.STATES];
states[0] = new PrincipalMenu();
states[1] = GameManager.getGameManager();
states[2] = new PauseMenu();
states[3] = new ScoreMenu();
states[4] = new GameRules();
states[5] = new Win();
}
@Override
public boolean onTouchEvent(MotionEvent event) {
int x = (int) event.getX();
int y = (int) event.getY();
if (event.getAction() == MotionEvent.ACTION_MOVE) {
gameManager.onTouchEvent(x, y);
}
invalidate();
return true;
}
public static Entity makeVisual(Entity entity, float width, float height, String image) {
VisualComponent visual = GameManager.getGame().engine.createComponent(VisualComponent.class);
final Texture texture =
new Texture(Gdx.files.internal(image != null ? image : images.random()));
visual.region = new TextureRegion(texture, texture.getWidth(), texture.getHeight());
visual.width = width;
visual.height = height;
entity.add(visual);
return entity;
}
@Test
public void getSessionShouldReturnCreatedGame() {
when(mockGameFactory.create(1, 0, false, false, null, false, GameMode.WHOLE))
.thenReturn(mockGame1);
gameManager.getOrCreateMatchingSession(
GameMode.WHOLE,
null,
0,
null,
EnumSet.of(ProblemGenre.Anige),
EnumSet.of(ProblemType.Marubatsu),
false,
mockServerStatusManager,
12345678,
"192.168.0.1");
Game game = gameManager.getSession(1);
assertSame(mockGame1, game);
}
public void removePlayer() {
player.teleport(spawnBack);
if (gm.getPlugin().getConfigHandler().isSaveHealth()) {
player.setHealth(health);
player.setFoodLevel(hunger);
}
player.getInventory().clear();
player.getInventory().setContents(inventory);
player.setGameMode(gamemode);
player.setExp(xpAmount);
}
@Test
public void getNumberOfPlayersInWholeShouldReturnNumberOfHumanPlayers() {
when(mockGameFactory.create(1, 0, false, false, null, false, GameMode.WHOLE))
.thenReturn(mockGame1);
when(mockGame1.getNumberOfHumanPlayer()).thenReturn(3);
when(mockGame1.getTransition()).thenReturn(Transition.Matching);
gameManager.getOrCreateMatchingSession(
GameMode.WHOLE,
null,
0,
null,
EnumSet.of(ProblemGenre.Anige),
EnumSet.of(ProblemType.Marubatsu),
false,
mockServerStatusManager,
12345678,
"192.168.0.1");
assertEquals(3, gameManager.getNumberOfPlayersInWhole());
}
public static Entity createHomingEnemy(
float x, float y, float width, float height, Entity homingTarget) {
Entity entity = createBasicMovingEntity(x, y, width, height);
makeVisual(entity, width, height, null);
makeHoming(entity, homingTarget);
Mappers.propel.get(entity).speed = 2f;
GameManager.getGame().engine.addEntity(entity);
return entity;
}
public void showMenu(Player p) {
GameManager.getInstance().openKitMenu(p);
Inventory i =
Bukkit.getServer()
.createInventory(p, 45, ChatColor.RED + "" + ChatColor.BOLD + "Please select a kit:");
int a = 0;
int b = 0;
ArrayList<Kit> kits = GameManager.getInstance().getKits(p);
if (kits == null
|| kits.size() == 0
|| !SettingsManager.getInstance().getKits().getBoolean("enabled")) {
GameManager.getInstance().leaveKitMenu(p);
return;
}
for (Kit k : kits) {
ItemStack i1 = k.getIcon();
ItemMeta im = i1.getItemMeta();
im.setDisplayName(ChatColor.GOLD + "" + ChatColor.BOLD + k.getName());
i1.setItemMeta(im);
i.setItem((9 * a) + b, i1);
a = 2;
for (ItemStack s2 : k.getContents()) {
if (s2 != null) {
i.setItem((9 * a) + b, s2);
a++;
}
}
a = 0;
b++;
}
p.openInventory(i);
debug("Showing kit menu for: " + p.getName());
}
@Override
public void run() {
if (gameManager.isForceStop()) {
Bukkit.getScheduler().cancelTask(timeState);
return;
}
if (timeLeft != 0) {
onRunnableTick(timeLeft);
timeLeft--;
} else {
onScheduleEnd(timeState);
}
}
public void addSpectator(final Player p) {
if (mode != GameMode.INGAME) {
msgmgr.sendMessage(PrefixType.WARNING, "You can only spectate running games!", p);
return;
}
p.teleport(SettingsManager.getInstance().getSpawnPoint(gameID, 1).add(0, 10, 0));
HookManager.getInstance().runHook("PLAYER_SPECTATE", "player-" + p.getName());
for (Player pl : Bukkit.getOnlinePlayers()) {
pl.hidePlayer(p);
}
Bukkit.getServer()
.getScheduler()
.scheduleSyncDelayedTask(
GameManager.getInstance().getPlugin(),
new Runnable() {
@SuppressWarnings("deprecation")
public void run() {
p.setFlying(false);
p.setAllowFlight(false);
p.setWalkSpeed(0.2F);
p.setFireTicks(0);
p.getInventory().clear();
p.getEquipment().setArmorContents(null);
p.updateInventory();
showMenu(p);
for (PotionEffect effect : p.getActivePotionEffects()) {
p.removePotionEffect(effect.getType());
}
}
},
1L);
spectators.add(p.getName());
msgmgr.sendMessage(
PrefixType.INFO,
"You are now spectating! Use /sg spectate again to return to the lobby.",
p);
msgmgr.sendMessage(
PrefixType.INFO,
"Right click while holding shift to teleport to the next ingame player, left click to go back.",
p);
nextspec.put(p, 0);
}
void startTimer() {
if (mGameManager != null && !mGameManager.isGameFinished()) {
mGameManager.startTimer();
TimerTask timerTask =
new TimerTask() {
@Override
public void run() {
runOnUiThread(
new Runnable() {
@Override
public void run() {
updateTimeElapsed(mGameManager.getElapsedTime());
}
});
}
};
mTimer = new Timer();
// Delay: 0, Interval: 1000ms
mTimer.schedule(timerTask, 0, 1000);
}
}
public static Entity createBasicMovingEntity(float x, float y, float width, float height) {
Entity entity = GameManager.getGame().engine.createEntity();
PositionComponent position =
GameManager.getGame().engine.createComponent(PositionComponent.class);
position.x = x;
position.y = y;
entity.add(position);
CollisionComponent collision =
GameManager.getGame().engine.createComponent(CollisionComponent.class);
collision.init(width, height);
entity.add(collision);
entity.add(GameManager.getGame().engine.createComponent(AccelerationComponent.class));
entity.add(GameManager.getGame().engine.createComponent(DragComponent.class));
entity.add(GameManager.getGame().engine.createComponent(VelocityComponent.class));
entity.add(GameManager.getGame().engine.createComponent(AngleComponent.class));
entity.add(GameManager.getGame().engine.createComponent(PropelComponent.class));
entity.add(
GameManager.getGame().engine.createComponent(StopMovementOnCollisionComponent.class));
return entity;
}
/*
*
* ################################################
*
* RESET
*
* ################################################
*
*
*/
public void resetArena() {
for (Integer i : tasks) {
Bukkit.getScheduler().cancelTask(i);
}
tasks.clear();
vote = 0;
voted.clear();
mode = GameMode.RESETING;
endgameRunning = false;
Bukkit.getScheduler().cancelTask(endgameTaskID);
GameManager.getInstance().gameEndCallBack(gameID);
QueueManager.getInstance().rollback(gameID, false);
LobbyManager.getInstance().updateWall(gameID);
scoreBoard.reset();
}
