Merge pull request #10155 from Adam-/layout

Add layout chat command

http-api/src/main/java/net/runelite/http/api/chat/ChatClient.java

@@ -309,4 +309,51 @@ public class ChatClient
 			throw new IOException(ex);
 		}
 	}
+
+	public boolean submitLayout(String username, LayoutRoom[] rooms) throws IOException
+	{
+		HttpUrl url = RuneLiteAPI.getApiBase().newBuilder()
+			.addPathSegment("chat")
+			.addPathSegment("layout")
+			.addQueryParameter("name", username)
+			.build();
+
+		Request request = new Request.Builder()
+			.post(RequestBody.create(RuneLiteAPI.JSON, RuneLiteAPI.GSON.toJson(rooms)))
+			.url(url)
+			.build();
+
+		try (Response response = RuneLiteAPI.CLIENT.newCall(request).execute())
+		{
+			return response.isSuccessful();
+		}
+	}
+
+	public LayoutRoom[] getLayout(String username) throws IOException
+	{
+		HttpUrl url = RuneLiteAPI.getApiBase().newBuilder()
+			.addPathSegment("chat")
+			.addPathSegment("layout")
+			.addQueryParameter("name", username)
+			.build();
+
+		Request request = new Request.Builder()
+			.url(url)
+			.build();
+
+		try (Response response = RuneLiteAPI.CLIENT.newCall(request).execute())
+		{
+			if (!response.isSuccessful())
+			{
+				throw new IOException("Unable to look up layout!");
+			}
+
+			InputStream in = response.body().byteStream();
+			return RuneLiteAPI.GSON.fromJson(new InputStreamReader(in), LayoutRoom[].class);
+		}
+		catch (JsonParseException ex)
+		{
+			throw new IOException(ex);
+		}
+	}
 }

http-api/src/main/java/net/runelite/http/api/chat/LayoutRoom.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2019, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package net.runelite.http.api.chat;
+
+public enum LayoutRoom
+{
+	START,
+	END,
+	SCAVENGERS,
+	FARMING,
+	EMPTY,
+
+	TEKTON,
+	MUTTADILES,
+	GUARDIANS,
+	VESPULA,
+	SHAMANS,
+	VASA,
+	VANGUARDS,
+	MYSTICS,
+	UNKNOWN_COMBAT,
+
+	CRABS,
+	ICE_DEMON,
+	TIGHTROPE,
+	THIEVING,
+	UNKNOWN_PUZZLE;
+}

http-service/src/main/java/net/runelite/http/service/chat/ChatController.java

@@ -30,11 +30,13 @@ import java.util.concurrent.TimeUnit;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import net.runelite.http.api.chat.Duels;
+import net.runelite.http.api.chat.LayoutRoom;
 import net.runelite.http.api.chat.Task;
 import net.runelite.http.service.util.exception.NotFoundException;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
@@ -208,4 +210,23 @@ public class ChatController
 		}
 		return duels;
 	}
+
+	@PostMapping("/layout")
+	public void submitLayout(@RequestParam String name, @RequestBody LayoutRoom[] rooms)
+	{
+		chatService.setLayout(name, rooms);
+	}
+
+	@GetMapping("/layout")
+	public LayoutRoom[] getLayout(@RequestParam String name)
+	{
+		LayoutRoom[] layout = chatService.getLayout(name);
+
+		if (layout == null)
+		{
+			throw new NotFoundException();
+		}
+
+		return layout;
+	}
 }

http-service/src/main/java/net/runelite/http/service/chat/ChatService.java

@@ -24,9 +24,13 @@
  */
 package net.runelite.http.service.chat;
 
+import com.google.common.base.Joiner;
+import com.google.common.base.Splitter;
 import com.google.common.collect.ImmutableMap;
 import java.time.Duration;
+import java.util.List;
 import java.util.Map;
+import net.runelite.http.api.chat.LayoutRoom;
 import net.runelite.http.api.chat.Task;
 import net.runelite.http.api.chat.Duels;
 import net.runelite.http.service.util.redis.RedisPool;
@@ -198,4 +202,31 @@ public class ChatService
 			jedis.expire(key, (int) EXPIRE.getSeconds());
 		}
 	}
+
+	public LayoutRoom[] getLayout(String name)
+	{
+		String layout;
+		try (Jedis jedis = jedisPool.getResource())
+		{
+			layout = jedis.get("layout." + name);
+		}
+
+		if (layout == null)
+		{
+			return null;
+		}
+
+		List<String> roomList = Splitter.on(' ').splitToList(layout);
+		return roomList.stream()
+			.map(LayoutRoom::valueOf)
+			.toArray(LayoutRoom[]::new);
+	}
+
+	public void setLayout(String name, LayoutRoom[] rooms)
+	{
+		try (Jedis jedis = jedisPool.getResource())
+		{
+			jedis.setex("layout." + name, (int) EXPIRE.getSeconds(), Joiner.on(' ').join(rooms));
+		}
+	}
 }

runelite-client/src/main/java/net/runelite/client/plugins/raids/Raid.java

@@ -24,9 +24,7 @@
  */
 package net.runelite.client.plugins.raids;
 
-import com.google.common.base.Joiner;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import lombok.Getter;
 import net.runelite.client.plugins.raids.solver.Layout;
@@ -60,19 +58,8 @@ public class Raid
 
 			if (room == null)
 			{
-				RaidRoom.Type type = RaidRoom.Type.fromCode(layout.getRoomAt(i).getSymbol());
+				RoomType type = RoomType.fromCode(layout.getRoomAt(i).getSymbol());
-				room = new RaidRoom(null, type);
+				room = type.getUnsolvedRoom();
-
-				if (type == RaidRoom.Type.COMBAT)
-				{
-					room.setBoss(RaidRoom.Boss.UNKNOWN);
-				}
-
-				if (type == RaidRoom.Type.PUZZLE)
-				{
-					room.setPuzzle(RaidRoom.Puzzle.UNKNOWN);
-				}
-
 				setRoom(room, i);
 			}
 		}
@@ -91,7 +78,7 @@ public class Raid
 		}
 	}
 
-	public RaidRoom[] getCombatRooms()
+	RaidRoom[] getCombatRooms()
 	{
 		List<RaidRoom> combatRooms = new ArrayList<>();
 
@@ -102,18 +89,13 @@ public class Raid
 				continue;
 			}
 
-			if (rooms[room.getPosition()].getType() == RaidRoom.Type.COMBAT)
+			if (rooms[room.getPosition()].getType() == RoomType.COMBAT)
 			{
 				combatRooms.add(rooms[room.getPosition()]);
 			}
 		}
 
-		return combatRooms.toArray(new RaidRoom[combatRooms.size()]);
+		return combatRooms.toArray(new RaidRoom[0]);
-	}
-
-	public String getRotationString()
-	{
-		return Joiner.on(",").join(Arrays.stream(getCombatRooms()).map(r -> r.getBoss().getName()).toArray());
 	}
 
 	public String toCode()
@@ -144,7 +126,7 @@ public class Raid
 			final int position = r.getPosition();
 			final RaidRoom room = getRoom(position);
 
-			if (room == null || !(room.getType() == RaidRoom.Type.COMBAT || room.getType() == RaidRoom.Type.PUZZLE))
+			if (room == null)
 			{
 				continue;
 			}
@@ -152,26 +134,8 @@ public class Raid
 			switch (room.getType())
 			{
 				case PUZZLE:
-					final RaidRoom.Puzzle puzzle = room.getPuzzle();
-					sb.append(puzzle.getName());
-
-					if (puzzle == RaidRoom.Puzzle.UNKNOWN)
-					{
-						sb.append(" (puzzle)");
-					}
-
-					sb.append(", ");
-					break;
 				case COMBAT:
-					final RaidRoom.Boss boss = room.getBoss();
+					sb.append(room.getName()).append(", ");
-					sb.append(boss.getName());
-
-					if (boss == RaidRoom.Boss.UNKNOWN)
-					{
-						sb.append(" (combat)");
-					}
-
-					sb.append(", ");
 					break;
 			}
 		}

runelite-client/src/main/java/net/runelite/client/plugins/raids/RaidRoom.java

@@ -24,144 +24,37 @@
  */
 package net.runelite.client.plugins.raids;
 
-import lombok.AllArgsConstructor;
 import lombok.Getter;
-import lombok.Setter;
+import lombok.RequiredArgsConstructor;
-import net.runelite.api.Tile;
 
-public class RaidRoom
+@RequiredArgsConstructor
+@Getter
+enum RaidRoom
 {
-	public static final int ROOM_MAX_SIZE = 32;
+	START("Start", RoomType.START),
+	END("End", RoomType.END),
+	SCAVENGERS("Scavengers", RoomType.SCAVENGERS),
+	FARMING("Farming", RoomType.FARMING),
+	EMPTY("Empty", RoomType.EMPTY),
 
-	@AllArgsConstructor
+	TEKTON("Tekton", RoomType.COMBAT),
-	public enum Type
+	MUTTADILES("Muttadiles", RoomType.COMBAT),
-	{
+	GUARDIANS("Guardians", RoomType.COMBAT),
-		START("Start", "#"),
+	VESPULA("Vespula", RoomType.COMBAT),
-		END("End", "¤"),
+	SHAMANS("Shamans", RoomType.COMBAT),
-		SCAVENGERS("Scavengers", "S"),
+	VASA("Vasa", RoomType.COMBAT),
-		FARMING("Farming", "F"),
+	VANGUARDS("Vanguards", RoomType.COMBAT),
-		COMBAT("Combat", "C"),
+	MYSTICS("Mystics", RoomType.COMBAT),
-		PUZZLE("Puzzle", "P"),
+	UNKNOWN_COMBAT("Unknown (combat)", RoomType.COMBAT),
-		EMPTY("Empty", " ");
 
-		@Getter
+	CRABS("Crabs", RoomType.PUZZLE),
-		private final String name;
+	ICE_DEMON("Ice Demon", RoomType.PUZZLE),
+	TIGHTROPE("Tightrope", RoomType.PUZZLE),
+	THIEVING("Thieving", RoomType.PUZZLE),
+	UNKNOWN_PUZZLE("Unknown (puzzle)", RoomType.PUZZLE);
 
-		@Getter
+	static final int ROOM_MAX_SIZE = 32;
-		private final String code;
 
-		public static Type fromCode(char code)
+	private final String name;
-		{
+	private final RoomType type;
-			for (Type type : Type.values())
-			{
-				if (type.getCode().equalsIgnoreCase(String.valueOf(code)))
-				{
-					return type;
-				}
-			}
-
-			return Type.EMPTY;
-		}
-	}
-
-	@AllArgsConstructor
-	public enum Boss
-	{
-		TEKTON("Tekton"),
-		MUTTADILES("Muttadiles"),
-		GUARDIANS("Guardians"),
-		VESPULA("Vespula"),
-		SHAMANS("Shamans"),
-		VASA("Vasa"),
-		VANGUARDS("Vanguards"),
-		MYSTICS("Mystics"),
-		UNKNOWN("Unknown");
-
-		@Getter
-		private final String name;
-
-		public static Boss fromString(String name)
-		{
-			for (Boss boss : Boss.values())
-			{
-				if (boss.getName().equalsIgnoreCase(name))
-				{
-					return boss;
-				}
-			}
-
-			return null;
-		}
-	}
-
-	@AllArgsConstructor
-	public enum Puzzle
-	{
-		CRABS("Crabs"),
-		ICE_DEMON("Ice Demon"),
-		TIGHTROPE("Tightrope"),
-		THIEVING("Thieving"),
-		UNKNOWN("Unknown");
-
-		@Getter
-		private final String name;
-
-		public static Puzzle fromString(String name)
-		{
-			for (Puzzle puzzle : Puzzle.values())
-			{
-				if (puzzle.getName().equalsIgnoreCase(name))
-				{
-					return puzzle;
-				}
-			}
-
-			return null;
-		}
-	}
-
-	@Getter
-	private final Tile base;
-
-	@Getter
-	@Setter
-	private Type type;
-
-	@Getter
-	@Setter
-	private Boss boss;
-
-	@Getter
-	@Setter
-	private Puzzle puzzle;
-
-	@Getter
-	@Setter
-	private RaidRoom previousRoom;
-
-	@Getter
-	@Setter
-	private RaidRoom nextRoom;
-
-	public RaidRoom(Tile base, Type type)
-	{
-		this.base = base;
-		this.type = type;
-	}
-
-	@Override
-	public String toString()
-	{
-		switch (type)
-		{
-			case COMBAT:
-				return "RaidRoom (type: " + type.getName() + ", " + boss.getName() + ")";
-
-			case PUZZLE:
-				return "RaidRoom (type: " + type.getName() + ", " + puzzle.getName() + ")";
-
-			default:
-				return "RaidRoom (type: " + type.getName() + ")";
-		}
-	}
 }

runelite-client/src/main/java/net/runelite/client/plugins/raids/RaidsOverlay.java

@@ -125,37 +125,41 @@ public class RaidsOverlay extends Overlay
 			{
 				case COMBAT:
 					bossCount++;
-					if (plugin.getRoomWhitelist().contains(room.getBoss().getName().toLowerCase()))
+					if (plugin.getRoomWhitelist().contains(room.getName().toLowerCase()))
 					{
 						color = Color.GREEN;
 					}
-					else if (plugin.getRoomBlacklist().contains(room.getBoss().getName().toLowerCase())
+					else if (plugin.getRoomBlacklist().contains(room.getName().toLowerCase())
 							|| config.enableRotationWhitelist() && bossCount > bossMatches)
 					{
 						color = Color.RED;
 					}
 
+					String name = room == RaidRoom.UNKNOWN_COMBAT ? "Unknown" : room.getName();
+
 					panelComponent.getChildren().add(LineComponent.builder()
 						.left(room.getType().getName())
-						.right(room.getBoss().getName())
+						.right(name)
 						.rightColor(color)
 						.build());
 
 					break;
 
 				case PUZZLE:
-					if (plugin.getRoomWhitelist().contains(room.getPuzzle().getName().toLowerCase()))
+					if (plugin.getRoomWhitelist().contains(room.getName().toLowerCase()))
 					{
 						color = Color.GREEN;
 					}
-					else if (plugin.getRoomBlacklist().contains(room.getPuzzle().getName().toLowerCase()))
+					else if (plugin.getRoomBlacklist().contains(room.getName().toLowerCase()))
 					{
 						color = Color.RED;
 					}
 
+					name = room == RaidRoom.UNKNOWN_PUZZLE ? "Unknown" : room.getName();
+
 					panelComponent.getChildren().add(LineComponent.builder()
 						.left(room.getType().getName())
-						.right(room.getPuzzle().getName())
+						.right(name)
 						.rightColor(color)
 						.build());
 					break;

runelite-client/src/main/java/net/runelite/client/plugins/raids/RaidsPlugin.java

@@ -24,14 +24,18 @@
  */
 package net.runelite.client.plugins.raids;
 
+import com.google.common.base.Joiner;
 import com.google.inject.Binder;
 import com.google.inject.Provides;
+import java.io.IOException;
 import java.text.DecimalFormat;
 import java.time.Instant;
 import java.util.ArrayList;
-import java.util.List;
+import java.util.Arrays;
+import java.util.concurrent.ScheduledExecutorService;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 import javax.inject.Inject;
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
@@ -40,6 +44,7 @@ import net.runelite.api.Client;
 import net.runelite.api.GameState;
 import net.runelite.api.InstanceTemplates;
 import net.runelite.api.MenuAction;
+import net.runelite.api.MessageNode;
 import net.runelite.api.NullObjectID;
 import static net.runelite.api.Perspective.SCENE_SIZE;
 import net.runelite.api.Point;
@@ -52,24 +57,28 @@ import net.runelite.client.events.ConfigChanged;
 import net.runelite.api.events.VarbitChanged;
 import net.runelite.client.callback.ClientThread;
 import net.runelite.client.chat.ChatColorType;
+import net.runelite.client.chat.ChatCommandManager;
 import net.runelite.client.chat.ChatMessageBuilder;
 import net.runelite.client.chat.ChatMessageManager;
 import net.runelite.client.chat.QueuedMessage;
 import net.runelite.client.config.ConfigManager;
 import net.runelite.client.eventbus.Subscribe;
+import net.runelite.client.events.ChatInput;
 import net.runelite.client.events.OverlayMenuClicked;
 import net.runelite.client.game.SpriteManager;
 import net.runelite.client.plugins.Plugin;
 import net.runelite.client.plugins.PluginDescriptor;
 import net.runelite.client.plugins.raids.solver.Layout;
 import net.runelite.client.plugins.raids.solver.LayoutSolver;
-import net.runelite.client.plugins.raids.solver.RotationSolver;
 import net.runelite.client.ui.overlay.OverlayManager;
 import net.runelite.client.ui.overlay.infobox.InfoBoxManager;
 import net.runelite.client.util.Text;
+import static net.runelite.client.util.Text.sanitize;
 import net.runelite.client.ws.PartyMember;
 import net.runelite.client.ws.PartyService;
 import net.runelite.client.ws.WSClient;
+import net.runelite.http.api.chat.ChatClient;
+import net.runelite.http.api.chat.LayoutRoom;
 import net.runelite.http.api.ws.messages.party.PartyChatMessage;
 
 @PluginDescriptor(
@@ -87,6 +96,7 @@ public class RaidsPlugin extends Plugin
 	private static final DecimalFormat DECIMAL_FORMAT = new DecimalFormat("###.##");
 	private static final DecimalFormat POINTS_FORMAT = new DecimalFormat("#,###");
 	private static final Pattern ROTATION_REGEX = Pattern.compile("\\[(.*?)]");
+	private static final String LAYOUT_COMMAND = "!layout";
 
 	@Inject
 	private ChatMessageManager chatMessageManager;
@@ -121,6 +131,15 @@ public class RaidsPlugin extends Plugin
 	@Inject
 	private WSClient ws;
 
+	@Inject
+	private ChatCommandManager chatCommandManager;
+
+	@Inject
+	private ChatClient chatClient;
+
+	@Inject
+	private ScheduledExecutorService scheduledExecutorService;
+
 	@Getter
 	private final ArrayList<String> roomWhitelist = new ArrayList<>();
 
@@ -159,11 +178,13 @@ public class RaidsPlugin extends Plugin
 		overlayManager.add(overlay);
 		updateLists();
 		clientThread.invokeLater(() -> checkRaidPresence(true));
+		chatCommandManager.registerCommandAsync(LAYOUT_COMMAND, this::lookupRaid, this::submitRaid);
 	}
 
 	@Override
 	protected void shutDown() throws Exception
 	{
+		chatCommandManager.unregisterCommand(LAYOUT_COMMAND);
 		overlayManager.remove(overlay);
 		infoBoxManager.removeInfoBox(timer);
 		inRaidChambers = false;
@@ -408,39 +429,13 @@ public class RaidsPlugin extends Plugin
 
 	int getRotationMatches()
 	{
-		String rotation = raid.getRotationString().toLowerCase();
+		RaidRoom[] combatRooms = raid.getCombatRooms();
-		List<String> bosses = Text.fromCSV(rotation);
+		String rotation = Arrays.stream(combatRooms)
+			.map(RaidRoom::getName)
+			.map(String::toLowerCase)
+			.collect(Collectors.joining(","));
 
-		if (rotationWhitelist.contains(rotation))
+		return rotationWhitelist.contains(rotation) ? combatRooms.length : 0;
-		{
-			return bosses.size();
-		}
-
-		for (String whitelisted : rotationWhitelist)
-		{
-			int matches = 0;
-			List<String> whitelistedBosses = Text.fromCSV(whitelisted);
-
-			for (int i = 0; i < whitelistedBosses.size(); i++)
-			{
-				if (i < bosses.size() && whitelistedBosses.get(i).equals(bosses.get(i)))
-				{
-					matches++;
-				}
-				else
-				{
-					matches = 0;
-					break;
-				}
-			}
-
-			if (matches >= 2)
-			{
-				return matches;
-			}
-		}
-
-		return 0;
 	}
 
 	private Point findLobbyBase()
@@ -544,97 +539,152 @@ public class RaidsPlugin extends Plugin
 
 	private RaidRoom determineRoom(Tile base)
 	{
-		RaidRoom room = new RaidRoom(base, RaidRoom.Type.EMPTY);
 		int chunkData = client.getInstanceTemplateChunks()[base.getPlane()][(base.getSceneLocation().getX()) / 8][base.getSceneLocation().getY() / 8];
 		InstanceTemplates template = InstanceTemplates.findMatch(chunkData);
 
 		if (template == null)
 		{
-			return room;
+			return RaidRoom.EMPTY;
 		}
 
 		switch (template)
 		{
 			case RAIDS_LOBBY:
 			case RAIDS_START:
-				room.setType(RaidRoom.Type.START);
+				return RaidRoom.START;
-				break;
 
 			case RAIDS_END:
-				room.setType(RaidRoom.Type.END);
+				return RaidRoom.END;
-				break;
 
 			case RAIDS_SCAVENGERS:
 			case RAIDS_SCAVENGERS2:
-				room.setType(RaidRoom.Type.SCAVENGERS);
+				return RaidRoom.SCAVENGERS;
-				break;
 
 			case RAIDS_SHAMANS:
-				room.setType(RaidRoom.Type.COMBAT);
+				return RaidRoom.SHAMANS;
-				room.setBoss(RaidRoom.Boss.SHAMANS);
-				break;
 
 			case RAIDS_VASA:
-				room.setType(RaidRoom.Type.COMBAT);
+				return RaidRoom.VASA;
-				room.setBoss(RaidRoom.Boss.VASA);
-				break;
 
 			case RAIDS_VANGUARDS:
-				room.setType(RaidRoom.Type.COMBAT);
+				return RaidRoom.VANGUARDS;
-				room.setBoss(RaidRoom.Boss.VANGUARDS);
-				break;
 
 			case RAIDS_ICE_DEMON:
-				room.setType(RaidRoom.Type.PUZZLE);
+				return RaidRoom.ICE_DEMON;
-				room.setPuzzle(RaidRoom.Puzzle.ICE_DEMON);
-				break;
 
 			case RAIDS_THIEVING:
-				room.setType(RaidRoom.Type.PUZZLE);
+				return RaidRoom.THIEVING;
-				room.setPuzzle(RaidRoom.Puzzle.THIEVING);
-				break;
 
 			case RAIDS_FARMING:
 			case RAIDS_FARMING2:
-				room.setType(RaidRoom.Type.FARMING);
+				return RaidRoom.FARMING;
-				break;
 
 			case RAIDS_MUTTADILES:
-				room.setType(RaidRoom.Type.COMBAT);
+				return RaidRoom.MUTTADILES;
-				room.setBoss(RaidRoom.Boss.MUTTADILES);
-				break;
 
 			case RAIDS_MYSTICS:
-				room.setType(RaidRoom.Type.COMBAT);
+				return RaidRoom.MYSTICS;
-				room.setBoss(RaidRoom.Boss.MYSTICS);
-				break;
 
 			case RAIDS_TEKTON:
-				room.setType(RaidRoom.Type.COMBAT);
+				return RaidRoom.TEKTON;
-				room.setBoss(RaidRoom.Boss.TEKTON);
-				break;
 
 			case RAIDS_TIGHTROPE:
-				room.setType(RaidRoom.Type.PUZZLE);
+				return RaidRoom.TIGHTROPE;
-				room.setPuzzle(RaidRoom.Puzzle.TIGHTROPE);
-				break;
 
 			case RAIDS_GUARDIANS:
-				room.setType(RaidRoom.Type.COMBAT);
+				return RaidRoom.GUARDIANS;
-				room.setBoss(RaidRoom.Boss.GUARDIANS);
-				break;
 
 			case RAIDS_CRABS:
-				room.setType(RaidRoom.Type.PUZZLE);
+				return RaidRoom.CRABS;
-				room.setPuzzle(RaidRoom.Puzzle.CRABS);
-				break;
 
 			case RAIDS_VESPULA:
-				room.setType(RaidRoom.Type.COMBAT);
+				return RaidRoom.VESPULA;
-				room.setBoss(RaidRoom.Boss.VESPULA);
+
-				break;
+			default:
+				return RaidRoom.EMPTY;
+		}
+	}
+
+	private void lookupRaid(ChatMessage chatMessage, String s)
+	{
+		ChatMessageType type = chatMessage.getType();
+
+		final String player;
+		if (type.equals(ChatMessageType.PRIVATECHATOUT))
+		{
+			player = client.getLocalPlayer().getName();
+		}
+		else
+		{
+			player = sanitize(chatMessage.getName());
 		}
 
-		return room;
+		LayoutRoom[] layout;
+		try
+		{
+			layout = chatClient.getLayout(player);
+		}
+		catch (IOException ex)
+		{
+			log.debug("unable to lookup layout", ex);
+			return;
+		}
+
+		if (layout == null || layout.length == 0)
+		{
+			return;
+		}
+
+		String layoutMessage = Joiner.on(", ").join(Arrays.stream(layout)
+			.map(l -> RaidRoom.valueOf(l.name()))
+			.filter(room -> room.getType() == RoomType.COMBAT || room.getType() == RoomType.PUZZLE)
+			.map(RaidRoom::getName)
+			.toArray());
+
+		String response = new ChatMessageBuilder()
+			.append(ChatColorType.HIGHLIGHT)
+			.append("Layout: ")
+			.append(ChatColorType.NORMAL)
+			.append(layoutMessage)
+			.build();
+
+		log.debug("Setting response {}", response);
+		final MessageNode messageNode = chatMessage.getMessageNode();
+		messageNode.setRuneLiteFormatMessage(response);
+		chatMessageManager.update(messageNode);
+		client.refreshChat();
+	}
+
+	private boolean submitRaid(ChatInput chatInput, String s)
+	{
+		if (raid == null)
+		{
+			return false;
+		}
+
+		final String playerName = client.getLocalPlayer().getName();
+		RaidRoom[] rooms = raid.getRooms();
+
+		LayoutRoom[] layoutRooms = Arrays.stream(rooms)
+			.map(room -> LayoutRoom.valueOf(room.name()))
+			.toArray(LayoutRoom[]::new);
+
+		scheduledExecutorService.execute(() ->
+		{
+			try
+			{
+				chatClient.submitLayout(playerName, layoutRooms);
+			}
+			catch (Exception ex)
+			{
+				log.warn("unable to submit layout", ex);
+			}
+			finally
+			{
+				chatInput.resume();
+			}
+		});
+
+		return true;
 	}
 }

runelite-client/src/main/java/net/runelite/client/plugins/raids/RoomType.java

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2018, Kamiel
+ * Copyright (c) 2019, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package net.runelite.client.plugins.raids;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@AllArgsConstructor
+@Getter
+enum RoomType
+{
+	START("Start", '#'),
+	END("End", '¤'),
+	SCAVENGERS("Scavengers", 'S'),
+	FARMING("Farming", 'F'),
+	EMPTY("Empty", ' '),
+	COMBAT("Combat", 'C'),
+	PUZZLE("Puzzle", 'P');
+
+	private final String name;
+	private final char code;
+
+	RaidRoom getUnsolvedRoom()
+	{
+		switch (this)
+		{
+			case START:
+				return RaidRoom.START;
+			case END:
+				return RaidRoom.END;
+			case SCAVENGERS:
+				return RaidRoom.SCAVENGERS;
+			case FARMING:
+				return RaidRoom.FARMING;
+			case COMBAT:
+				return RaidRoom.UNKNOWN_COMBAT;
+			case PUZZLE:
+				return RaidRoom.UNKNOWN_PUZZLE;
+			case EMPTY:
+			default:
+				return RaidRoom.EMPTY;
+		}
+	}
+
+	static RoomType fromCode(char code)
+	{
+		for (RoomType type : values())
+		{
+			if (type.getCode() == code)
+			{
+				return type;
+			}
+		}
+
+		return EMPTY;
+	}
+}

runelite-client/src/main/java/net/runelite/client/plugins/raids/RotationSolver.java

@@ -22,58 +22,45 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-package net.runelite.client.plugins.raids.solver;
+package net.runelite.client.plugins.raids;
 
-import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collection;
+import java.util.List;
-import net.runelite.client.plugins.raids.RaidRoom;
+import static net.runelite.client.plugins.raids.RaidRoom.GUARDIANS;
-import net.runelite.client.plugins.raids.RaidRoom.Boss;
+import static net.runelite.client.plugins.raids.RaidRoom.MUTTADILES;
+import static net.runelite.client.plugins.raids.RaidRoom.MYSTICS;
+import static net.runelite.client.plugins.raids.RaidRoom.SHAMANS;
+import static net.runelite.client.plugins.raids.RaidRoom.TEKTON;
+import static net.runelite.client.plugins.raids.RaidRoom.UNKNOWN_COMBAT;
+import static net.runelite.client.plugins.raids.RaidRoom.VANGUARDS;
+import static net.runelite.client.plugins.raids.RaidRoom.VASA;
+import static net.runelite.client.plugins.raids.RaidRoom.VESPULA;
 
-public class RotationSolver
+class RotationSolver
 {
-	private static class Rotation<E> extends ArrayList<E>
+	private static final List[] ROTATIONS =
-	{
-		Rotation(Collection<? extends E> bosses)
 		{
-			super(bosses);
+			Arrays.asList(TEKTON, VASA, GUARDIANS, MYSTICS, SHAMANS, MUTTADILES, VANGUARDS, VESPULA),
-		}
+			Arrays.asList(TEKTON, MUTTADILES, GUARDIANS, VESPULA, SHAMANS, VASA, VANGUARDS, MYSTICS),
+			Arrays.asList(VESPULA, VANGUARDS, MUTTADILES, SHAMANS, MYSTICS, GUARDIANS, VASA, TEKTON),
+			Arrays.asList(MYSTICS, VANGUARDS, VASA, SHAMANS, VESPULA, GUARDIANS, MUTTADILES, TEKTON)
+		};
 
-		@Override
+	static boolean solve(RaidRoom[] rooms)
-		public E get(int index)
-		{
-			if (index < 0)
-			{
-				index = index + size();
-			}
-
-			return super.get(index % size());
-		}
-	}
-
-	private static final Rotation[] ROTATIONS =
-	{
-			new Rotation<>(Arrays.asList(Boss.TEKTON, Boss.VASA, Boss.GUARDIANS, Boss.MYSTICS, Boss.SHAMANS, Boss.MUTTADILES, Boss.VANGUARDS, Boss.VESPULA)),
-			new Rotation<>(Arrays.asList(Boss.TEKTON, Boss.MUTTADILES, Boss.GUARDIANS, Boss.VESPULA, Boss.SHAMANS, Boss.VASA, Boss.VANGUARDS, Boss.MYSTICS)),
-			new Rotation<>(Arrays.asList(Boss.VESPULA, Boss.VANGUARDS, Boss.MUTTADILES, Boss.SHAMANS, Boss.MYSTICS, Boss.GUARDIANS, Boss.VASA, Boss.TEKTON)),
-			new Rotation<>(Arrays.asList(Boss.MYSTICS, Boss.VANGUARDS, Boss.VASA, Boss.SHAMANS, Boss.VESPULA, Boss.GUARDIANS, Boss.MUTTADILES, Boss.TEKTON))
-	};
-
-	public static boolean solve(RaidRoom[] rooms)
 	{
 		if (rooms == null)
 		{
 			return false;
 		}
 
-		Rotation<Boss> match = null;
+		List<RaidRoom> match = null;
 		Integer start = null;
 		Integer index = null;
 		int known = 0;
 
 		for (int i = 0; i < rooms.length; i++)
 		{
-			if (rooms[i] == null || rooms[i].getBoss() == null || rooms[i].getBoss() == Boss.UNKNOWN)
+			if (rooms[i] == null || rooms[i].getType() != RoomType.COMBAT || rooms[i] == UNKNOWN_COMBAT)
 			{
 				continue;
 			}
@@ -96,21 +83,21 @@ public class RotationSolver
 			return true;
 		}
 
-		for (Rotation rotation : ROTATIONS)
+		for (List rotation : ROTATIONS)
 		{
 			COMPARE:
 			for (int i = 0; i < rotation.size(); i++)
 			{
-				if (rooms[start].getBoss() == rotation.get(i))
+				if (rooms[start] == rotation.get(i))
 				{
 					for (int j = start + 1; j < rooms.length; j++)
 					{
-						if (rooms[j].getBoss() == null || rooms[j].getBoss() == Boss.UNKNOWN)
+						if (rooms[j].getType() != RoomType.COMBAT || rooms[j] == UNKNOWN_COMBAT)
 						{
 							continue;
 						}
 
-						if (rooms[j].getBoss() != rotation.get(i + j - start))
+						if (rooms[j] != rotation.get((i + j - start) % rotation.size()))
 						{
 							break COMPARE;
 						}
@@ -139,9 +126,9 @@ public class RotationSolver
 				continue;
 			}
 
-			if (rooms[i].getBoss() == null || rooms[i].getBoss() == Boss.UNKNOWN)
+			if (rooms[i].getType() != RoomType.COMBAT || rooms[i] == UNKNOWN_COMBAT)
 			{
-				rooms[i].setBoss(match.get(index + i));
+				rooms[i] = match.get((index + i) % match.size());
 			}
 		}
 

runelite-client/src/test/java/net/runelite/client/plugins/raids/RotationSolverTest.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2019, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package net.runelite.client.plugins.raids;
+
+import static net.runelite.client.plugins.raids.RaidRoom.GUARDIANS;
+import static net.runelite.client.plugins.raids.RaidRoom.MUTTADILES;
+import static net.runelite.client.plugins.raids.RaidRoom.MYSTICS;
+import static net.runelite.client.plugins.raids.RaidRoom.SHAMANS;
+import static net.runelite.client.plugins.raids.RaidRoom.TEKTON;
+import static net.runelite.client.plugins.raids.RaidRoom.UNKNOWN_COMBAT;
+import static net.runelite.client.plugins.raids.RaidRoom.VANGUARDS;
+import static net.runelite.client.plugins.raids.RaidRoom.VASA;
+import static net.runelite.client.plugins.raids.RaidRoom.VESPULA;
+import static org.junit.Assert.assertArrayEquals;
+import org.junit.Test;
+
+public class RotationSolverTest
+{
+	@Test
+	public void testSolve1()
+	{
+		RaidRoom[] rooms = new RaidRoom[]{VESPULA, UNKNOWN_COMBAT, UNKNOWN_COMBAT, VANGUARDS};
+		RotationSolver.solve(rooms);
+		assertArrayEquals(new RaidRoom[]{VESPULA, SHAMANS, VASA, VANGUARDS}, rooms);
+	}
+
+	@Test
+	public void testSolve2()
+	{
+		RaidRoom[] rooms = new RaidRoom[]{UNKNOWN_COMBAT, UNKNOWN_COMBAT, MUTTADILES, TEKTON};
+		RotationSolver.solve(rooms);
+		assertArrayEquals(new RaidRoom[]{VESPULA, GUARDIANS, MUTTADILES, TEKTON}, rooms);
+	}
+
+	@Test
+	public void testSolve3()
+	{
+		RaidRoom[] rooms = new RaidRoom[]{TEKTON, UNKNOWN_COMBAT, GUARDIANS, MYSTICS};
+		RotationSolver.solve(rooms);
+		assertArrayEquals(new RaidRoom[]{TEKTON, VASA, GUARDIANS, MYSTICS}, rooms);
+	}
+
+	@Test
+	public void testSolve4()
+	{
+		RaidRoom[] rooms = new RaidRoom[]{VASA, UNKNOWN_COMBAT, UNKNOWN_COMBAT, GUARDIANS};
+		RotationSolver.solve(rooms);
+		assertArrayEquals(new RaidRoom[]{VASA, SHAMANS, VESPULA, GUARDIANS}, rooms);
+	}
+}