From 850f487080b0cc6bca91fb5968a7c0ef7396f9aa Mon Sep 17 00:00:00 2001 From: Adam Date: Tue, 18 Dec 2018 19:39:52 -0500 Subject: [PATCH] client: add cooking plugin Co-authored-by: Cronick Co-authored-by: Joris --- .../client/plugins/cooking/CookingConfig.java | 45 ++++++ .../plugins/cooking/CookingOverlay.java | 118 +++++++++++++++ .../client/plugins/cooking/CookingPlugin.java | 134 ++++++++++++++++++ .../plugins/cooking/CookingSession.java | 60 ++++++++ 4 files changed, 357 insertions(+) create mode 100644 runelite-client/src/main/java/net/runelite/client/plugins/cooking/CookingConfig.java create mode 100644 runelite-client/src/main/java/net/runelite/client/plugins/cooking/CookingOverlay.java create mode 100644 runelite-client/src/main/java/net/runelite/client/plugins/cooking/CookingPlugin.java create mode 100644 runelite-client/src/main/java/net/runelite/client/plugins/cooking/CookingSession.java diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/cooking/CookingConfig.java b/runelite-client/src/main/java/net/runelite/client/plugins/cooking/CookingConfig.java new file mode 100644 index 0000000000..f8ec60a607 --- /dev/null +++ b/runelite-client/src/main/java/net/runelite/client/plugins/cooking/CookingConfig.java @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2018, Joris K + * Copyright (c) 2018, Lasse + * 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.cooking; + +import net.runelite.client.config.Config; +import net.runelite.client.config.ConfigGroup; +import net.runelite.client.config.ConfigItem; + +@ConfigGroup("cooking") +public interface CookingConfig extends Config +{ + @ConfigItem( + position = 1, + keyName = "statTimeout", + name = "Reset stats (minutes)", + description = "Configures the time until the session resets and the overlay is hidden (0 = Disable feature)" + ) + default int statTimeout() + { + return 5; + } +} diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/cooking/CookingOverlay.java b/runelite-client/src/main/java/net/runelite/client/plugins/cooking/CookingOverlay.java new file mode 100644 index 0000000000..122c793430 --- /dev/null +++ b/runelite-client/src/main/java/net/runelite/client/plugins/cooking/CookingOverlay.java @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2018, Joris K + * Copyright (c) 2018, Lasse + * 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.cooking; + +import java.awt.Color; +import java.awt.Dimension; +import java.awt.Graphics2D; +import java.text.DecimalFormat; +import java.time.Instant; +import java.time.Duration; +import javax.inject.Inject; +import static net.runelite.api.AnimationID.COOKING_FIRE; +import static net.runelite.api.AnimationID.COOKING_RANGE; +import net.runelite.api.Client; +import net.runelite.api.Skill; +import net.runelite.client.plugins.xptracker.XpTrackerService; +import net.runelite.client.ui.overlay.Overlay; +import net.runelite.client.ui.overlay.OverlayPosition; +import net.runelite.client.ui.overlay.components.LineComponent; +import net.runelite.client.ui.overlay.components.PanelComponent; +import net.runelite.client.ui.overlay.components.TitleComponent; + +class CookingOverlay extends Overlay +{ + private static final int COOK_TIMEOUT = 3; + private static final DecimalFormat FORMAT = new DecimalFormat("#.#"); + + private final Client client; + private final CookingPlugin plugin; + private final CookingConfig config; + private final XpTrackerService xpTrackerService; + private final PanelComponent panelComponent = new PanelComponent(); + + @Inject + private CookingOverlay(Client client, CookingPlugin plugin, CookingConfig config, XpTrackerService xpTrackerService) + { + setPosition(OverlayPosition.TOP_LEFT); + this.client = client; + this.plugin = plugin; + this.config = config; + this.xpTrackerService = xpTrackerService; + } + + @Override + public Dimension render(Graphics2D graphics) + { + CookingSession session = plugin.getSession(); + if (session == null) + { + return null; + } + + panelComponent.setPreferredSize(new Dimension(145, 0)); + panelComponent.getChildren().clear(); + + if (isCooking() || Duration.between(session.getLastCookingAction(), Instant.now()).getSeconds() < COOK_TIMEOUT) + { + panelComponent.getChildren().add(TitleComponent.builder() + .text("Cooking") + .color(Color.GREEN) + .build()); + } + else + { + panelComponent.getChildren().add(TitleComponent.builder() + .text("NOT cooking") + .color(Color.RED) + .build()); + } + + panelComponent.getChildren().add(LineComponent.builder() + .left("Cooked:") + .right(session.getCookAmount() + (session.getCookAmount() >= 1 ? " (" + xpTrackerService.getActionsHr(Skill.COOKING) + "/hr)" : "")) + .build()); + + panelComponent.getChildren().add(LineComponent.builder() + .left("Burnt:") + .right(session.getBurnAmount() + (session.getBurnAmount() >= 1 ? " (" + FORMAT.format(session.getBurntPercentage()) + "%)" : "")) + .build()); + + return panelComponent.render(graphics); + } + + private boolean isCooking() + { + switch (client.getLocalPlayer().getAnimation()) + { + case COOKING_FIRE: + case COOKING_RANGE: + return true; + default: + return false; + } + } +} diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/cooking/CookingPlugin.java b/runelite-client/src/main/java/net/runelite/client/plugins/cooking/CookingPlugin.java new file mode 100644 index 0000000000..ef25bf1df5 --- /dev/null +++ b/runelite-client/src/main/java/net/runelite/client/plugins/cooking/CookingPlugin.java @@ -0,0 +1,134 @@ +/* + * Copyright (c) 2018, Joris K + * Copyright (c) 2018, Lasse + * 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.cooking; + +import java.time.Duration; +import java.time.Instant; +import javax.inject.Inject; +import lombok.AccessLevel; +import lombok.Getter; +import com.google.inject.Provides; +import net.runelite.api.ChatMessageType; +import net.runelite.api.events.ChatMessage; +import net.runelite.api.events.GameTick; +import net.runelite.client.config.ConfigManager; +import net.runelite.client.eventbus.Subscribe; +import net.runelite.client.plugins.Plugin; +import net.runelite.client.plugins.PluginDependency; +import net.runelite.client.plugins.PluginDescriptor; +import net.runelite.client.plugins.xptracker.XpTrackerPlugin; +import net.runelite.client.ui.overlay.OverlayManager; + +@PluginDescriptor( + name = "Cooking", + description = "Show cooking statistics", + tags = {"overlay", "skilling", "cook"} +) +@PluginDependency(XpTrackerPlugin.class) +public class CookingPlugin extends Plugin +{ + @Inject + private CookingConfig config; + + @Inject + private CookingOverlay overlay; + + @Inject + private OverlayManager overlayManager; + + @Getter(AccessLevel.PACKAGE) + private CookingSession session; + + @Provides + CookingConfig getConfig(ConfigManager configManager) + { + return configManager.getConfig(CookingConfig.class); + } + + @Override + protected void startUp() throws Exception + { + session = null; + overlayManager.add(overlay); + } + + @Override + protected void shutDown() throws Exception + { + overlayManager.remove(overlay); + session = null; + } + + @Subscribe + public void onGameTick(GameTick gameTick) + { + if (session == null || config.statTimeout() == 0) + { + return; + } + + Duration statTimeout = Duration.ofMinutes(config.statTimeout()); + Duration sinceCut = Duration.between(session.getLastCookingAction(), Instant.now()); + + if (sinceCut.compareTo(statTimeout) >= 0) + { + session = null; + } + } + + @Subscribe + public void onChatMessage(ChatMessage event) + { + if (event.getType() != ChatMessageType.FILTERED) + { + return; + } + + final String message = event.getMessage(); + + if (message.startsWith("You successfully cook") || message.startsWith("You successfully bake") || message.startsWith("You manage to cook") || message.startsWith("You roast a")) + { + if (session == null) + { + session = new CookingSession(); + } + + session.updateLastCookingAction(); + session.increaseCookAmount(); + + } + else if (message.startsWith("You accidentally burn")) + { + if (session == null) + { + session = new CookingSession(); + } + + session.updateLastCookingAction(); + session.increaseBurnAmount(); + } + } +} diff --git a/runelite-client/src/main/java/net/runelite/client/plugins/cooking/CookingSession.java b/runelite-client/src/main/java/net/runelite/client/plugins/cooking/CookingSession.java new file mode 100644 index 0000000000..292e4a3584 --- /dev/null +++ b/runelite-client/src/main/java/net/runelite/client/plugins/cooking/CookingSession.java @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2018, Joris K + * Copyright (c) 2018, Lasse + * 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.cooking; + +import java.time.Instant; +import lombok.AccessLevel; +import lombok.Getter; + +class CookingSession +{ + @Getter(AccessLevel.PACKAGE) + private Instant lastCookingAction; + @Getter(AccessLevel.PACKAGE) + private int cookAmount; + @Getter(AccessLevel.PACKAGE) + private int burnAmount; + + void updateLastCookingAction() + { + this.lastCookingAction = Instant.now(); + } + + void increaseCookAmount() + { + this.cookAmount++; + } + + void increaseBurnAmount() + { + this.burnAmount++; + } + + double getBurntPercentage() + { + return ((double) getBurnAmount() / (getCookAmount() + getBurnAmount())) * 100; + } +}