├── README.md
├── src
    └── jselfbot
    │   ├── utils
    │       ├── FormatUtil.java
    │       └── WrapUtil.java
    │   ├── Constants.java
    │   ├── commands
    │       ├── PingCmd.java
    │       ├── SetCmd.java
    │       ├── DeleteCmd.java
    │       ├── MeCmd.java
    │       ├── TimeCmd.java
    │       ├── EvalCmd.java
    │       ├── EmoteCmd.java
    │       ├── DiscrimCmd.java
    │       ├── GameCmd.java
    │       ├── ListCmd.java
    │       ├── ClearCmd.java
    │       ├── PollCmd.java
    │       ├── GoogleCmd.java
    │       ├── EmbedCmd.java
    │       ├── BashCmd.java
    │       ├── SpoilerCmd.java
    │       ├── AvatarCmd.java
    │       ├── QuoteCmd.java
    │       └── TodoCmd.java
    │   ├── JSelfBot.java
    │   ├── entities
    │       ├── GoogleSearcher.java
    │       ├── Emojis.java
    │       ├── Config.java
    │       ├── JagTagMethods.java
    │       ├── Todolist.java
    │       └── AnimatedGifEncoder.java
    │   ├── Command.java
    │   └── Bot.java
└── LICENSE


/README.md:
--------------------------------------------------------------------------------
 1 | # ⚠ All selfbots (and any other 3rd-party clients or client modifications) break Discord's [Terms of Service](https://discordapp.com/terms). Using a selfbot or any client mods puts your account at risk for deletion. Please do not use a selfbot nor any client modifications.
 2 | 
 3 | 🔗 Terms of Service: https://discordapp.com/terms
 4 | 
 5 | 🔗 API Terms of Service: https://discordapp.com/developers/docs/legal
 6 | 
 7 | 🔗 Community Guidelines: https://discordapp.com/guidelines
 8 | 
 9 | This project is no longer supported for the reasons detailed above.
10 | 


--------------------------------------------------------------------------------
/src/jselfbot/utils/FormatUtil.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * To change this license header, choose License Headers in Project Properties.
 3 |  * To change this template file, choose Tools | Templates
 4 |  * and open the template in the editor.
 5 |  */
 6 | package jselfbot.utils;
 7 | 
 8 | import java.util.List;
 9 | 
10 | /**
11 |  *
12 |  * @author John Grosh (john.a.grosh@gmail.com)
13 |  */
14 | public class FormatUtil
15 | {
16 |     
17 |     public static String join(List<String> strings, String joiner)
18 |     {
19 |         if(strings.isEmpty())
20 |             return "";
21 |         StringBuilder sb = new StringBuilder(strings.get(0));
22 |         for(int i=1; i<strings.size(); i++)
23 |             sb.append(joiner).append(strings.get(i));
24 |         return sb.toString();
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/jselfbot/Constants.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2016 John Grosh (jagrosh).
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *      http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package jselfbot;
17 | 
18 | /**
19 |  *
20 |  * @author John Grosh (jagrosh)
21 |  */
22 | public class Constants {
23 |     public static final String VERSION = "1.2";
24 |     public static final String FAILURE = "\u274C";
25 | }
26 | 


--------------------------------------------------------------------------------
/src/jselfbot/commands/PingCmd.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2016 John Grosh (jagrosh).
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *      http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package jselfbot.commands;
17 | 
18 | import java.time.temporal.ChronoUnit;
19 | import jselfbot.Command;
20 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
21 | 
22 | /**
23 |  *
24 |  * @author John Grosh (jagrosh)
25 |  */
26 | public class PingCmd extends Command {
27 | 
28 |     public PingCmd()
29 |     {
30 |         this.name = "ping";
31 |         this.description = "checks bot's connection";
32 |         this.type = Type.KEEP_AND_RESEND;
33 |     }
34 |     
35 |     @Override
36 |     protected void execute(String args, MessageReceivedEvent event) {
37 |         event.getMessage().editMessage("Pinging...")
38 |                 .queue(m -> m.editMessage("Ping: "+m.getCreationTime().until(m.getEditedTime(), ChronoUnit.MILLIS)+"ms")
39 |                         .queue());
40 |     }
41 |     
42 | }
43 | 


--------------------------------------------------------------------------------
/src/jselfbot/commands/SetCmd.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2016 John Grosh (jagrosh).
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *      http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package jselfbot.commands;
17 | 
18 | import jselfbot.Command;
19 | import jselfbot.entities.Emojis;
20 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
21 | 
22 | /**
23 |  *
24 |  * @author John Grosh (jagrosh)
25 |  */
26 | public class SetCmd extends Command {
27 |     private final Emojis emojis;
28 |     public SetCmd(Emojis emojis)
29 |     {
30 |         this.emojis = emojis;
31 |         this.name = "set";
32 |         this.description = "sets a :custom: emoji";
33 |         this.arguments = "<name> <replacement>";
34 |     }
35 |     
36 |     @Override
37 |     protected void execute(String args, MessageReceivedEvent event) {
38 |         String[] parts = args.split("\\s+",2);
39 |         if(parts.length<2)
40 |         {
41 |             tempReply("Must include an emoji name and its content", event);
42 |             return;
43 |         }
44 |         emojis.setEmoji(parts[0], parts[1]);
45 |         tempReply("Added emoji `:\u200E"+parts[0]+":` that will convert to `"+parts[1]+"`", event);
46 |     }
47 |     
48 | }
49 | 


--------------------------------------------------------------------------------
/src/jselfbot/commands/DeleteCmd.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2016 John Grosh (jagrosh).
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *      http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package jselfbot.commands;
17 | 
18 | import jselfbot.Command;
19 | import jselfbot.entities.Emojis;
20 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
21 | 
22 | /**
23 |  *
24 |  * @author John Grosh (jagrosh)
25 |  */
26 | public class DeleteCmd extends Command {
27 |     private final Emojis emojis;
28 |     public DeleteCmd(Emojis emojis)
29 |     {
30 |         this.emojis = emojis;
31 |         this.name = "delete";
32 |         this.description = "deletes a :custom: emoji";
33 |         this.arguments = "<name>";
34 |     }
35 |     
36 |     @Override
37 |     protected void execute(String args, MessageReceivedEvent event) {
38 |         if(args.isEmpty())
39 |         {
40 |             tempReply("Please include an emoji name.", event);
41 |             return;
42 |         }
43 |         String[] parts = args.split("\\s+",2);
44 |         boolean deleted = emojis.deleteEmoji(parts[0]);
45 |         if(deleted)
46 |             tempReply("Deleted emoji `:\u200E"+parts[0]+":`", event);
47 |         else
48 |             tempReply("Emoji `"+parts[0]+"` was not found.", event);
49 |     }
50 |     
51 | }
52 | 


--------------------------------------------------------------------------------
/src/jselfbot/commands/MeCmd.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2016 John Grosh (jagrosh).
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *      http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package jselfbot.commands;
17 | 
18 | import jselfbot.Command;
19 | import net.dv8tion.jda.core.EmbedBuilder;
20 | import net.dv8tion.jda.core.entities.Member;
21 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
22 | 
23 | /**
24 |  *
25 |  * @author John Grosh (jagrosh)
26 |  */
27 | public class MeCmd extends Command {
28 | 
29 |     public MeCmd()
30 |     {
31 |         this.name = "me";
32 |         this.description = "says things";
33 |         this.arguments = "<stuff>";
34 |     }
35 |     
36 |     @Override
37 |     protected void execute(String args, MessageReceivedEvent event) {
38 |         EmbedBuilder builder = new EmbedBuilder();
39 |         String username;
40 |         if(event.getGuild()!=null)
41 |         {
42 |             Member member = event.getGuild().getSelfMember();
43 |             builder.setColor(member.getColor());
44 |             username = member.getEffectiveName();
45 |         }
46 |         else
47 |             username = event.getAuthor().getName();
48 |         builder.setDescription("***"+username+"*** *"+args+"*");
49 |         reply(builder.build(), event);
50 |     }
51 |     
52 | }
53 | 


--------------------------------------------------------------------------------
/src/jselfbot/commands/TimeCmd.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2016 John Grosh (jagrosh).
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *      http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package jselfbot.commands;
17 | 
18 | import java.time.ZoneId;
19 | import java.time.ZonedDateTime;
20 | import java.time.format.DateTimeFormatter;
21 | import jselfbot.Command;
22 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
23 | 
24 | /**
25 |  *
26 |  * @author John Grosh (jagrosh)
27 |  */
28 | public class TimeCmd extends Command {
29 |     private final ZoneId zone;
30 |     public TimeCmd(ZoneId zone)
31 |     {
32 |         this.zone = zone;
33 |         this.name = "time";
34 |         this.description = "checks the time";
35 |         this.type = Type.EDIT_ORIGINAL;
36 |     }
37 |     
38 |     @Override
39 |     protected void execute(String args, MessageReceivedEvent event) {
40 |         ZonedDateTime t = event.getMessage().getCreationTime().atZoneSameInstant(zone);
41 |         String time = t.format(DateTimeFormatter.ofPattern("h:mma"));
42 |         String time24 = t.format(DateTimeFormatter.ofPattern("HH:mm"));
43 |         String name = event.getGuild()==null ? event.getAuthor().getName() : event.getMember().getEffectiveName();
44 |         reply("\u231A Current time for **"+name+"** is `"+time+"` (`"+time24+"`)", event);
45 |     }
46 |     
47 | }
48 | 


--------------------------------------------------------------------------------
/src/jselfbot/commands/EvalCmd.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2016 John Grosh (jagrosh).
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *      http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package jselfbot.commands;
17 | 
18 | import javax.script.ScriptEngine;
19 | import javax.script.ScriptEngineManager;
20 | import jselfbot.Command;
21 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
22 | 
23 | /**
24 |  *
25 |  * @author John Grosh (jagrosh)
26 |  */
27 | public class EvalCmd extends Command {
28 | 
29 |     public EvalCmd()
30 |     {
31 |         this.name = "eval";
32 |         this.description = "evaluates using Nashorn";
33 |         this.arguments = "<script>";
34 |         this.type = Type.EDIT_ORIGINAL;
35 |     }
36 |     
37 |     @Override
38 |     protected void execute(String args, MessageReceivedEvent event) {
39 |         ScriptEngine se = new ScriptEngineManager().getEngineByName("Nashorn");
40 |         se.put("event", event);
41 |         se.put("jda", event.getJDA());
42 |         se.put("guild", event.getGuild());
43 |         se.put("channel", event.getChannel());
44 |         try
45 |         {
46 |             reply("```java\n"+args+" ```"+"Evaluated Successfully:\n```\n"+se.eval(args)+" ```", event);
47 |         } 
48 |         catch(Exception e)
49 |         {
50 |             reply("```java\n"+args+" ```"+"An exception was thrown:\n```\n"+e+" ```", event);
51 |         }
52 |     }
53 |     
54 | }
55 | 


--------------------------------------------------------------------------------
/src/jselfbot/JSelfBot.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2016 John Grosh (jagrosh).
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *      http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package jselfbot;
17 | 
18 | import javax.security.auth.login.LoginException;
19 | import jselfbot.entities.Config;
20 | import net.dv8tion.jda.core.AccountType;
21 | import net.dv8tion.jda.core.JDABuilder;
22 | import net.dv8tion.jda.core.exceptions.RateLimitedException;
23 | import org.slf4j.LoggerFactory;
24 | 
25 | /**
26 |  *
27 |  * @author John Grosh (jagrosh)
28 |  */
29 | public class JSelfBot {
30 |     
31 |     /**
32 |      * @param args the command line arguments
33 |      */
34 |     public static void main(String[] args){
35 |         Config config;
36 |         try{
37 |             config = new Config();
38 |         } catch(Exception e) {
39 |             LoggerFactory.getLogger("Config").error(""+e);
40 |             return;
41 |         }
42 |         try {
43 |             new JDABuilder(config.isForBot() ? AccountType.BOT : AccountType.CLIENT)
44 |                     .setToken(config.getToken())
45 |                     .addEventListener(new Bot(config))
46 |                     .setStatus(config.getStatus())
47 |                     .setIdle(true)
48 |                     .buildAsync();
49 |         } catch(LoginException | IllegalArgumentException | RateLimitedException e) {
50 |             LoggerFactory.getLogger("Config").error(""+e);
51 |         }
52 |     }
53 |     
54 | }
55 | 


--------------------------------------------------------------------------------
/src/jselfbot/commands/EmoteCmd.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2016 John Grosh (jagrosh).
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *      http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package jselfbot.commands;
17 | 
18 | import jselfbot.Command;
19 | import net.dv8tion.jda.core.EmbedBuilder;
20 | import net.dv8tion.jda.core.entities.Emote;
21 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
22 | 
23 | /**
24 |  *
25 |  * @author John Grosh (jagrosh)
26 |  */
27 | public class EmoteCmd extends Command {
28 | 
29 |     public EmoteCmd()
30 |     {
31 |         this.name = "emote";
32 |         this.description = "checks info about an emote";
33 |         this.arguments = "<:emote:>";
34 |     }
35 |     
36 |     @Override
37 |     protected void execute(String args, MessageReceivedEvent event) {
38 |         String id = args.replaceAll("<:.+:(\\d+)>", "$1");
39 |         Emote emote = event.getJDA().getEmoteById(id);
40 |         if(emote==null)
41 |             tempReply("Invalid emote or emote ID", event);
42 |         else
43 |         {
44 |             EmbedBuilder builder = new EmbedBuilder();
45 |             if(event.getGuild()!=null)
46 |                 builder.setColor(event.getGuild().getSelfMember().getColor());
47 |             builder.setImage(emote.getImageUrl());
48 |             builder.setDescription(emote.getAsMention()+" **:"+emote.getName()+":**\nID: **"+emote.getId()+"**\nGuild: **"+emote.getGuild().getName()+"**");
49 |             reply(builder.build(), event);
50 |         }
51 |     }
52 |     
53 | }
54 | 


--------------------------------------------------------------------------------
/src/jselfbot/commands/DiscrimCmd.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2016 John Grosh (jagrosh).
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *      http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package jselfbot.commands;
17 | 
18 | import jselfbot.Command;
19 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
20 | 
21 | /**
22 |  *
23 |  * @author John Grosh (jagrosh)
24 |  */
25 | public class DiscrimCmd extends Command {
26 | 
27 |     public DiscrimCmd()
28 |     {
29 |         this.name = "discrim";
30 |         this.description = "finds users with your/a discrim";
31 |         this.arguments = "[discrim]";
32 |         this.type = Type.EDIT_ORIGINAL;
33 |     }
34 |     
35 |     @Override
36 |     protected void execute(String args, MessageReceivedEvent event) {
37 |         String discrim;
38 |         if(args==null || args.isEmpty())
39 |             discrim = event.getJDA().getSelfUser().getDiscriminator();
40 |         else if (!args.matches("\\d{4}"))
41 |         {
42 |             tempReply("Invalid discrim! (Must be a 4-digit number)", event);
43 |             return;
44 |         }
45 |         else
46 |             discrim = args;
47 |         StringBuilder builder = new StringBuilder();
48 |         event.getJDA().getUsers().stream().filter(u -> u.getDiscriminator().equals(discrim)).forEach(u -> {
49 |             if(builder.length()<1940)
50 |                 builder.append("`").append(u.getName()).append("` ");
51 |         });
52 |         if(builder.length()==0)
53 |             tempReply("No users found with discrim #"+discrim, event);
54 |         else
55 |             reply("Users with discrim #"+discrim+":\n"+builder.toString(), event);
56 |     }
57 |     
58 | }
59 | 


--------------------------------------------------------------------------------
/src/jselfbot/commands/GameCmd.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2016 John Grosh (jagrosh).
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *      http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package jselfbot.commands;
17 | 
18 | import jselfbot.Command;
19 | import net.dv8tion.jda.core.entities.Game;
20 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
21 | 
22 | /**
23 |  *
24 |  * @author John Grosh (jagrosh)
25 |  */
26 | public class GameCmd extends Command {
27 | 
28 |     public GameCmd()
29 |     {
30 |         this.name = "setgame";
31 |         this.description = "sets or clears your current game";
32 |         this.arguments = "[game]";
33 |     }
34 |     
35 |     @Override
36 |     protected void execute(String args, MessageReceivedEvent event) {
37 |         String result;
38 |         if(args.isEmpty())
39 |         {
40 |             event.getJDA().getPresence().setGame(null);
41 |             result = "Game cleared.";
42 |         }
43 |         else
44 |         {
45 |             try {
46 |                 Game game;
47 |                 if(args.startsWith("twitch"))
48 |                 {
49 |                     String[] parts = args.substring(6).trim().split("\\s+",2);
50 |                     args = parts[1];
51 |                     game = Game.of(args, "http://twitch.tv/"+parts[0]);
52 |                 }
53 |                 else
54 |                     game = Game.of(args);
55 |                 event.getJDA().getPresence().setGame(game);
56 |                 result = "Game set to "+(game.getUrl()==null ? "Playing": "Streaming")+" `"+args+"`. Note that it will appear to everyone else but will not show in your own client.";
57 |             } catch(Exception e) {
58 |                 result = "Game could not be set to `"+args+"`";
59 |             }
60 |         }
61 |         tempReply(result, event);
62 |     }
63 |     
64 | }
65 | 


--------------------------------------------------------------------------------
/src/jselfbot/commands/ListCmd.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2016 John Grosh (jagrosh).
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *      http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package jselfbot.commands;
17 | 
18 | import java.util.Collection;
19 | import jselfbot.Command;
20 | import jselfbot.entities.Emojis;
21 | import net.dv8tion.jda.core.EmbedBuilder;
22 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
23 | 
24 | /**
25 |  *
26 |  * @author John Grosh (jagrosh)
27 |  */
28 | public class ListCmd extends Command {
29 |     private final Emojis emojis;
30 |     public ListCmd(Emojis emojis)
31 |     {
32 |         this.emojis = emojis;
33 |         this.name = "list";
34 |         this.description = "lists custom emojis";
35 |     }
36 |     
37 |     @Override
38 |     protected void execute(String args, MessageReceivedEvent event) {
39 |         Collection<String> list = emojis.getEmojiList();
40 |         if(list.isEmpty())
41 |         {
42 |             tempReply("No custom emojis!", event);
43 |             return;
44 |         }
45 |         
46 |         EmbedBuilder builder = new EmbedBuilder();
47 |         if(event.getGuild()!=null)
48 |             builder.setColor(event.getGuild().getSelfMember().getColor());
49 |         builder.setAuthor("Custom Emojis:", null, null);
50 |         
51 |         StringBuilder sbuilder = new StringBuilder();
52 |         for(String ename: list)
53 |         {
54 |             String next = "\n`:"+ename+":` \u27A1 `"+emojis.getEmoji(ename)+"`";
55 |             if(sbuilder.length()+next.length()>1985)
56 |             {
57 |                 reply(builder.setDescription(sbuilder.toString().trim()).build(),event);
58 |                 builder.setAuthor(null,null,null);
59 |                 sbuilder = new StringBuilder();
60 |             }
61 |             sbuilder.append(next);
62 |         }
63 |         
64 |         builder.setDescription(sbuilder.toString().trim());
65 |         reply(builder.build(), event);
66 |     }
67 |     
68 | }
69 | 


--------------------------------------------------------------------------------
/src/jselfbot/commands/ClearCmd.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2016 John Grosh (jagrosh).
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *      http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package jselfbot.commands;
17 | 
18 | import java.util.List;
19 | import java.util.stream.Collectors;
20 | import jselfbot.Command;
21 | import net.dv8tion.jda.core.entities.Message;
22 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
23 | 
24 | /**
25 |  *
26 |  * @author John Grosh (jagrosh)
27 |  */
28 | public class ClearCmd extends Command {
29 | 
30 |     public ClearCmd()
31 |     {
32 |         this.name = "clear";
33 |         this.description = "deletes self messages within limit";
34 |         this.arguments = "<number> (default 100, max 100)";
35 |     }
36 |     
37 |     @Override
38 |     protected void execute(String args, MessageReceivedEvent event) {
39 |         int num = 100;
40 |         try {
41 |         if(!args.isEmpty())
42 |             num = Integer.parseInt(args);
43 |         } catch(NumberFormatException e) {
44 |             tempReply("`"+args+"` is not a valid number between 1 and 100.", event);
45 |             return;
46 |         }
47 |         if(num<1 || num>100)
48 |         {
49 |             tempReply("`"+args+"` is not a valid number between 1 and 100.", event);
50 |             return;
51 |         }
52 |         try {
53 |             event.getChannel().getHistory().retrievePast(num==100 ? 100 : num+1).queue(success -> {
54 |                 List<Message> list = success.stream().filter(m -> event.getJDA().getSelfUser().equals(m.getAuthor()) && !event.getMessage().equals(m)).collect(Collectors.toList());
55 |                 list.forEach(m -> m.delete().queue());
56 |                 tempReply("Deleting "+list.size()+" messages.", event);
57 |             }, failure -> {
58 |                 tempReply("Failed retrieve messages.", event);
59 |             });
60 |         } catch(Exception e) {
61 |             tempReply("Could not retrieve messages.", event);
62 |         }
63 |     }
64 |     
65 | }
66 | 


--------------------------------------------------------------------------------
/src/jselfbot/commands/PollCmd.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2016 John Grosh (jagrosh).
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *      http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package jselfbot.commands;
17 | 
18 | import jselfbot.Command;
19 | import net.dv8tion.jda.core.EmbedBuilder;
20 | import net.dv8tion.jda.core.entities.Member;
21 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
22 | 
23 | /**
24 |  *
25 |  * @author John Grosh (jagrosh)
26 |  */
27 | public class PollCmd extends Command {
28 |     private final int REGIONAL_A = "\uD83C\uDDE6".codePointAt(0);
29 |     public PollCmd()
30 |     {
31 |         this.name = "poll";
32 |         this.description = "makes a poll";
33 |         this.arguments = "<question> or <question>|<option1>|<option2>...";
34 |         this.type = Type.EDIT_ORIGINAL;
35 |     }
36 |     
37 |     @Override
38 |     protected void execute(String args, MessageReceivedEvent event) {
39 |         String[] parts = args.split("\\|");
40 |         if(parts.length==1)
41 |         {
42 |             reply(formatQuestion(args), event, m -> 
43 |             {
44 |                 m.addReaction("\uD83D\uDC4D").queue();
45 |                 m.addReaction("\uD83D\uDC4E").queue();
46 |             });
47 |         }
48 |         else
49 |         {
50 |             StringBuilder builder = new StringBuilder(formatQuestion(parts[0]));
51 |             for(int i=1; i<parts.length; i++)
52 |             {
53 |                 String r = String.copyValueOf(Character.toChars(REGIONAL_A+i-1));
54 |                 builder.append("\n").append(r).append(" ").append(parts[i].trim());
55 |             }
56 |             reply(builder.toString(), event, m -> 
57 |             {
58 |                 for(int i=1; i<parts.length; i++)
59 |                     m.addReaction(String.copyValueOf(Character.toChars(REGIONAL_A+i-1))).queue();
60 |             });
61 |         }
62 |     }
63 |     
64 |     private static String formatQuestion(String str)
65 |     {
66 |         return "\uD83D\uDDF3 **"+str+"**";
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/src/jselfbot/commands/GoogleCmd.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2016 John Grosh (jagrosh).
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *      http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package jselfbot.commands;
17 | 
18 | import java.util.ArrayList;
19 | import jselfbot.Command;
20 | import jselfbot.entities.GoogleSearcher;
21 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
22 | 
23 | /**
24 |  *
25 |  * @author John Grosh (jagrosh)
26 |  */
27 | public class GoogleCmd extends Command {
28 |     private final GoogleSearcher google;
29 |     public GoogleCmd()
30 |     {
31 |         google = new GoogleSearcher();
32 |         this.name = "google";
33 |         this.description = "search google";
34 |         this.arguments = "[num] <query>";
35 |         this.type = Type.EDIT_ORIGINAL;
36 |     }
37 |     
38 |     @Override
39 |     protected void execute(String args, MessageReceivedEvent event) {
40 |         String[] parts = args.split("\\s+", 2);
41 |         int num = 1;
42 |         String query;
43 |         if(parts.length >1 && parts[0].matches("\\d+"))
44 |         {
45 |             num = Integer.parseInt(parts[0]);
46 |             query = parts[1];
47 |         }
48 |         else
49 |             query = args;
50 |         if(num<1 || num>10)
51 |         {
52 |             tempReply("Can only search 1 to 10 results at once!", event);
53 |             return;
54 |         }
55 |         ArrayList<String> results = google.getDataFromGoogle(query);
56 |         if(results == null)
57 |         {
58 |             tempReply("Error, could not search google", event);
59 |         }
60 |         else if(results.isEmpty())
61 |         {
62 |             tempReply("No results found for `"+query+"`", event);
63 |         }
64 |         else
65 |         {
66 |             StringBuilder builder = new StringBuilder("`"+query+"` \uD83D\uDD0E "+results.get(0));
67 |             if(num>1 && results.size()>1)
68 |             {
69 |                 builder.append("\nSee also:");
70 |                 for(int i=1; i<num && i<results.size(); i++)
71 |                     builder.append("\n<").append(results.get(i)).append(">");
72 |             }
73 |             reply(builder.toString(), event);
74 |         }
75 |     }
76 |     
77 | }
78 | 


--------------------------------------------------------------------------------
/src/jselfbot/entities/GoogleSearcher.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2016 John Grosh (jagrosh).
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *      http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package jselfbot.entities;
17 | 
18 | import java.io.IOException;
19 | import java.io.UnsupportedEncodingException;
20 | import java.net.URLDecoder;
21 | import java.net.URLEncoder;
22 | import java.util.ArrayList;
23 | import org.jsoup.Jsoup;
24 | import org.jsoup.nodes.Document;
25 | import org.jsoup.select.Elements;
26 | import org.slf4j.LoggerFactory;
27 | 
28 | /**
29 |  *
30 |  * @author John Grosh (jagrosh)
31 |  */
32 | public class GoogleSearcher {
33 |     
34 |     public ArrayList<String> getDataFromGoogle(String query) {
35 |         String request;
36 |         try {
37 |             request = "https://www.google.com/search?q=" + URLEncoder.encode(query, "UTF-8") + "&num=20";
38 |         } catch (UnsupportedEncodingException ex) {
39 |             System.err.println(ex);
40 |             return null;
41 |         }
42 |         //System.out.println("Sending request..." + request);
43 |         ArrayList<String> result;
44 |         try {
45 | 
46 |             // need http protocol
47 |             Document doc = Jsoup
48 |                     .connect(request)
49 |                     .userAgent(
50 |                       "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)")
51 |                     .timeout(5000).get();
52 | 
53 |             // get all links
54 |             Elements links = doc.select("a[href]");
55 |             result = new ArrayList<>();
56 |             links.stream().map((link) -> link.attr("href")).filter((temp) -> (temp.startsWith("/url?q="))).forEach((temp) -> {
57 |                 try {
58 |                     //result.add(temp.substring(7,temp.indexOf("&sa="))+"\n");
59 |                     String rslt = URLDecoder.decode(temp.substring(7,temp.indexOf("&sa=")),"UTF-8");
60 |                     if(!rslt.contains("/settings/ads/preferences") && !rslt.startsWith("http://webcache.googleusercontent.com"))
61 |                         result.add(rslt);
62 |                 } catch (UnsupportedEncodingException ex) {
63 |                 }
64 |             });
65 |         } catch (IOException e) {
66 |             LoggerFactory.getLogger("Google").error("Search failure: "+e.toString());
67 |             return null;
68 |         }
69 |         return result;
70 |     }
71 | }


--------------------------------------------------------------------------------
/src/jselfbot/commands/EmbedCmd.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2016 John Grosh (jagrosh).
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *      http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package jselfbot.commands;
17 | 
18 | import jselfbot.Command;
19 | import jselfbot.Constants;
20 | import jselfbot.entities.JagTagMethods;
21 | import com.jagrosh.jagtag.Parser;
22 | import com.jagrosh.jagtag.ParserBuilder;
23 | import net.dv8tion.jda.core.EmbedBuilder;
24 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
25 | 
26 | /**
27 |  *
28 |  * @author John Grosh (jagrosh)
29 |  */
30 | public class EmbedCmd extends Command {
31 | 
32 |     private final Parser parser;
33 |     public EmbedCmd()
34 |     {
35 |         this.name = "embed";
36 |         this.description = "puts text in an embed";
37 |         this.arguments = "<stuff>";
38 |         this.parser = new ParserBuilder()
39 |                 .addMethods(JagTagMethods.getMethods())
40 |                 .setMaxOutput(2048)
41 |                 .setMaxIterations(1000)
42 |                 .build();
43 |     }
44 |     
45 |     @Override
46 |     protected void execute(String args, MessageReceivedEvent event) {
47 |         if(args==null || args.isEmpty())
48 |         {
49 |             reply("Embeds:\n"
50 |                     + "`{title:`TEXT`|`URL`}` or `{title:`TEXT`}`\n"
51 |                     + "`{author:`NAME`|`IMAGE`|`URL`}` or `{author:`NAME`|`IMAGE`}` or `{author:`NAME`}`\n"
52 |                     + "`{thumbnail:`IMAGE`}`\n"
53 |                     + "`{field:`NAME`|`VALUE`|`true/false`}` or `{field:`NAME`|`VALUE`}` *can include multiple fields\n"
54 |                     + "`{image:`IMAGE`}`\n"
55 |                     + "`{color:`#HEX`}` or `{color:name}`\n"
56 |                     + "`{footer:`TEXT`|`IMAGE`}` or `{footer:`TEXT`}`\n"
57 |                     + "`{timestamp:`ISO`}` or `{timestamp}` *current time if nothing included\n"
58 |                     + "Any remaining text goes into the description", event);
59 |             return;
60 |         }
61 |         EmbedBuilder builder = new EmbedBuilder();
62 |         if(event.getGuild()!=null)
63 |             builder.setColor(event.getGuild().getSelfMember().getColor());
64 |         parser.put("builder", builder);
65 |         try {
66 |             String descr = parser.parse(args).trim();
67 |             if(!descr.isEmpty())
68 |                 builder.setDescription(descr);
69 |             reply(builder.build(), event);
70 |         } catch(Exception e) {
71 |             reply(Constants.FAILURE+" Error: "+e, event);
72 |         }
73 |     }
74 |     
75 | }
76 | 


--------------------------------------------------------------------------------
/src/jselfbot/commands/BashCmd.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (C) 2017 Artu
 3 |  *
 4 |  * This program is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * This program is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | package jselfbot.commands;
18 | 
19 | import java.io.BufferedReader;
20 | import java.io.IOException;
21 | import java.io.InputStreamReader;
22 | import jselfbot.Command;
23 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
24 | import org.slf4j.Logger;
25 | import org.slf4j.LoggerFactory;
26 | 
27 | /**
28 |  * Runs a shell command.
29 |  * @author Spotlight
30 |  * @author Artu
31 |  */
32 | public class BashCmd extends Command {
33 |     
34 |     private final static Logger LOG = LoggerFactory.getLogger("Bash");
35 |     public BashCmd() {
36 |         this.name = "bash";
37 |         this.description = "run a command on a shell";
38 |     }
39 | 
40 |     @Override
41 |     protected void execute(String args, MessageReceivedEvent event) {
42 |         if(args.isEmpty()) {
43 |             reply("Cannot execute a empty command!", event);
44 |             return;
45 |         }
46 | 
47 |         StringBuilder output = new StringBuilder();
48 |         String finalOutput;
49 |         try {
50 |             ProcessBuilder builder = new ProcessBuilder(args.split(" "));
51 |             Process p = builder.start();
52 | 
53 |             BufferedReader reader =
54 |                     new BufferedReader(new InputStreamReader(p.getInputStream()));
55 | 
56 |             String runningLineOutput;
57 |             while ((runningLineOutput = reader.readLine())!= null) {
58 |                 output.append(runningLineOutput).append("\n");
59 |             }
60 | 
61 |             if (output.toString().isEmpty()) {
62 |                 reply("Done, with no output!", event);
63 |                 return;
64 |             }
65 | 
66 |             // Remove linebreak
67 |             finalOutput = output.substring(0, output.length() - 1);
68 |             reader.close();
69 |         } catch (IOException e) {
70 |             reply("I wasn't able to find the command `" + args + "`!", event);
71 |             return;
72 |         } catch (Exception e) {
73 |             LOG.warn("An unknown error occurred!");
74 |             e.printStackTrace();
75 |             reply("An unknown error occurred! Check the bot console.", event);
76 |             return;
77 |         }
78 | 
79 |         // Actually send
80 |         try {
81 |             reply("Input: ```\n" + args + "``` Output: \n```\n" + finalOutput + "```", event);
82 |         } catch (IllegalArgumentException e) {
83 |             LOG.info("Input: " + args + "\nOutput: " + finalOutput);
84 |             reply("Command output too long! Output sent in console.", event);
85 |         }
86 |     }
87 | }
88 | 


--------------------------------------------------------------------------------
/src/jselfbot/entities/Emojis.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2016 John Grosh (jagrosh).
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *      http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | package jselfbot.entities;
17 | 
18 | import java.io.BufferedWriter;
19 | import java.io.FileOutputStream;
20 | import java.io.IOException;
21 | import java.io.OutputStreamWriter;
22 | import java.io.Writer;
23 | import java.nio.file.Files;
24 | import java.nio.file.Paths;
25 | import java.util.Collection;
26 | import java.util.HashMap;
27 | import jselfbot.utils.FormatUtil;
28 | import org.json.JSONException;
29 | import org.json.JSONObject;
30 | import org.slf4j.Logger;
31 | import org.slf4j.LoggerFactory;
32 | 
33 | /**
34 |  *
35 |  * @author John Grosh (jagrosh)
36 |  */
37 | public class Emojis {
38 |     private final HashMap<String, String> emojis;
39 |     private final static String FILENAME = "emojis.json";
40 |     private final static Logger LOG = LoggerFactory.getLogger("Emojis");
41 |     
42 |     public Emojis()
43 |     {
44 |         emojis = new HashMap<>();
45 |         JSONObject obj;
46 |         try {
47 |             obj = new JSONObject(FormatUtil.join(Files.readAllLines(Paths.get(FILENAME)), "\n"));
48 |             obj.keySet().stream().forEach(name -> emojis.put(name.toLowerCase(), obj.getString(name)));
49 |             LOG.info("Successfully loaded "+emojis.keySet().size()+" custom emojis!");
50 |         } catch(IOException e) {
51 |             LOG.warn(FILENAME+" was not found! This can be ignored if you haven't set any custom emojis.");
52 |         } catch(JSONException e) {
53 |             LOG.error("The emojis file, "+FILENAME+" is corrupted. Please fix the file before adding emojis or the file will be overwritten.");
54 |         }
55 |     }
56 |     
57 |     private void write()
58 |     {
59 |         JSONObject obj = new JSONObject();
60 |         emojis.keySet().stream().forEach(name -> obj.put(name, emojis.get(name)));
61 |         try (Writer out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(FILENAME), "UTF-8"))) {
62 |             out.write(obj.toString(2));
63 |         }catch(IOException e) {
64 |             LOG.error("Failed to save emojis to "+FILENAME);
65 |         }
66 |     }
67 |     
68 |     public void setEmoji(String name, String content)
69 |     {
70 |         emojis.put(name.toLowerCase(), content);
71 |         write();
72 |     }
73 |     
74 |     public boolean deleteEmoji(String name)
75 |     {
76 |         boolean removed = emojis.remove(name.toLowerCase())!=null;
77 |         if(removed)
78 |             write();
79 |         return removed;
80 |     }
81 |     
82 |     public String getEmoji(String name)
83 |     {
84 |         return emojis.get(name.toLowerCase());
85 |     }
86 |     
87 |     public Collection<String> getEmojiList()
88 |     {
89 |         return emojis.keySet();
90 |     }
91 | }
92 | 


--------------------------------------------------------------------------------
/src/jselfbot/Command.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2016 John Grosh (jagrosh).
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *      http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | package jselfbot;
 17 | 
 18 | import java.util.function.Consumer;
 19 | import net.dv8tion.jda.core.MessageBuilder;
 20 | import net.dv8tion.jda.core.entities.Message;
 21 | import net.dv8tion.jda.core.entities.MessageEmbed;
 22 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
 23 | import net.dv8tion.jda.core.requests.RestAction;
 24 | 
 25 | /**
 26 |  *
 27 |  * @author John Grosh (jagrosh)
 28 |  */
 29 | public abstract class Command {
 30 |     protected String name = "null";
 31 |     protected String description = "No description provided";
 32 |     protected String arguments = null;
 33 |     protected Type type = Type.DELETE_AND_RESEND;
 34 |     
 35 |     protected abstract void execute(String args, MessageReceivedEvent event);
 36 |     
 37 |     public void run(String args, MessageReceivedEvent event)
 38 |     {
 39 |         try {
 40 |             if(type == Type.DELETE_AND_RESEND)
 41 |                 event.getMessage().delete().queue();
 42 |             execute(args, event);
 43 |         } catch(Exception e) {
 44 |             failure(event);
 45 |             throw e;
 46 |         }
 47 |     }
 48 |     
 49 |     protected void reply(String reply, MessageReceivedEvent event)
 50 |     {
 51 |         if(type == Type.EDIT_ORIGINAL)
 52 |             event.getMessage().editMessage(reply).queue();
 53 |         else
 54 |             event.getChannel().sendMessage(reply).queue();
 55 |     }
 56 |     
 57 |     protected void reply(String reply, MessageReceivedEvent event, Consumer<Message> consumer)
 58 |     {
 59 |         if(type == Type.EDIT_ORIGINAL)
 60 |             event.getMessage().editMessage(reply).queue(consumer);
 61 |         else
 62 |             event.getChannel().sendMessage(reply).queue(consumer);
 63 |     }
 64 |     
 65 |     protected void reply(MessageEmbed embed, MessageReceivedEvent event)
 66 |     {
 67 |         if(type == Type.EDIT_ORIGINAL)
 68 |             event.getMessage().editMessage(new MessageBuilder().setEmbed(embed).build()).queue();
 69 |         else
 70 |             event.getChannel().sendMessage(new MessageBuilder().setEmbed(embed).build()).queue();
 71 |     }
 72 |     
 73 |     protected void reply(MessageEmbed embed, MessageReceivedEvent event, Consumer<Message> consumer)
 74 |     {
 75 |         if(type == Type.EDIT_ORIGINAL)
 76 |             event.getMessage().editMessage(new MessageBuilder().setEmbed(embed).build()).queue(consumer);
 77 |         else
 78 |             event.getChannel().sendMessage(new MessageBuilder().setEmbed(embed).build()).queue(consumer);
 79 |     }
 80 |     
 81 |     protected void failure(MessageReceivedEvent event)
 82 |     {
 83 |         tempReply(Constants.FAILURE, event);
 84 |     }
 85 |     
 86 |     protected void tempReply(String message, MessageReceivedEvent event)
 87 |     {
 88 |         RestAction<Message> action;
 89 |         if(type == Type.EDIT_ORIGINAL)
 90 |             action = event.getMessage().editMessage(message);
 91 |         else
 92 |             action = event.getChannel().sendMessage(message);
 93 |         action.queue(m -> {
 94 |             try{Thread.sleep(2000);}catch(Exception e){}
 95 |             m.delete().queue();
 96 |         });
 97 |     }
 98 |     
 99 |     public enum Type {
100 |         DELETE_AND_RESEND, EDIT_ORIGINAL, KEEP_AND_RESEND
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/src/jselfbot/commands/SpoilerCmd.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2016 John Grosh (jagrosh).
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *      http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | package jselfbot.commands;
 17 | 
 18 | import java.awt.Canvas;
 19 | import java.awt.Color;
 20 | import java.awt.Font;
 21 | import java.awt.Graphics2D;
 22 | import java.awt.RenderingHints;
 23 | import java.awt.image.BufferedImage;
 24 | import java.io.File;
 25 | import java.io.IOException;
 26 | import java.util.List;
 27 | import jselfbot.Command;
 28 | import jselfbot.entities.AnimatedGifEncoder;
 29 | import jselfbot.utils.WrapUtil;
 30 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
 31 | 
 32 | /**
 33 |  *
 34 |  * @author John Grosh (jagrosh)
 35 |  */
 36 | public class SpoilerCmd extends Command {
 37 |     private final Color DARKTHEME = new Color(54, 57, 62);
 38 |     private final Color HOVERCOLOR = new Color(155,155,155);
 39 |     private final Color TEXTCOLOR = Color.WHITE;
 40 |     private final Font FONT = new Font("Arial", Font.PLAIN, 15);
 41 |     private final int BUFFER = 3;
 42 |     public SpoilerCmd()
 43 |     {
 44 |         this.name = "spoiler";
 45 |         this.description = "creates a spoiler image";
 46 |         this.arguments = "<spoiler text>";
 47 |         this.type = Type.DELETE_AND_RESEND;
 48 |     }
 49 |     
 50 |     @Override
 51 |     protected void execute(String input, MessageReceivedEvent event) {
 52 |         if(input==null || input.isEmpty())
 53 |         {
 54 |             tempReply("Please include spoiler text", event);
 55 |             return;
 56 |         }
 57 |         try{
 58 |             Canvas c = new Canvas();
 59 |             List<String> lines = WrapUtil.wrap(input.replace("\n", " "), c.getFontMetrics(FONT), 400-(2*BUFFER)-2);
 60 |             if(lines.size()>8)
 61 |             {
 62 |                 tempReply("Too many lines (>8)", event);
 63 |                 return;
 64 |             }
 65 |             BufferedImage text = new BufferedImage(400,lines.size()*(FONT.getSize()+BUFFER)+2*BUFFER+2,BufferedImage.TYPE_INT_RGB);
 66 |             BufferedImage hover = new BufferedImage(400,lines.size()*(FONT.getSize()+BUFFER)+2*BUFFER+2,BufferedImage.TYPE_INT_RGB);
 67 |             Graphics2D textG = text.createGraphics();
 68 |             Graphics2D hoverG = hover.createGraphics();
 69 |             textG.setFont(FONT);
 70 |             hoverG.setFont(FONT);
 71 |             textG.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
 72 |             hoverG.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
 73 |             textG.setColor(DARKTHEME);
 74 |             hoverG.setColor(DARKTHEME);
 75 |             textG.fillRect(1, 1, text.getWidth()-2, text.getHeight()-2);
 76 |             hoverG.fillRect(1, 1, text.getWidth()-2, text.getHeight()-2);
 77 |             textG.setColor(TEXTCOLOR);
 78 |             hoverG.setColor(HOVERCOLOR);
 79 |             for(int i=0; i<lines.size(); i++)
 80 |                 textG.drawString(lines.get(i), BUFFER+1, (i+1)*(FONT.getSize()+BUFFER)-1);//text.getHeight()-BUFFER);
 81 |             hoverG.drawString("[ Hover to View Spoiler ]", BUFFER+1, FONT.getSize()+BUFFER-1);
 82 |             //ImageIO.write(text,"png", new File("text.png"));
 83 |             //ImageIO.write(hover,"png", new File("hover.png"));
 84 |             AnimatedGifEncoder e = new AnimatedGifEncoder();
 85 |             e.setRepeat(0);
 86 |             e.start("spoiler.gif");
 87 |             e.setDelay(1);
 88 |             e.addFrame(hover);
 89 |             e.setDelay(60000);
 90 |             e.addFrame(text);
 91 |             e.setDelay(60000);
 92 |             e.finish();
 93 |             event.getChannel().sendFile(new File("spoiler.gif"), null).queue();
 94 |             textG.dispose();
 95 |             hoverG.dispose();
 96 |         }catch(Exception e){
 97 |             tempReply("Failed to generate spoiler image", event);
 98 |             //e.printStackTrace();
 99 |         }
100 |     }
101 |     
102 | }
103 | 


--------------------------------------------------------------------------------
/src/jselfbot/entities/Config.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2016 John Grosh (jagrosh).
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *      http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | package jselfbot.entities;
 17 | 
 18 | import java.nio.file.Files;
 19 | import java.nio.file.Paths;
 20 | import java.time.ZoneId;
 21 | import java.util.List;
 22 | import net.dv8tion.jda.core.OnlineStatus;
 23 | import org.slf4j.Logger;
 24 | import org.slf4j.LoggerFactory;
 25 | 
 26 | /**
 27 |  *
 28 |  * @author John Grosh (jagrosh)
 29 |  */
 30 | public class Config {
 31 |     private final Logger LOG = LoggerFactory.getLogger("Config");
 32 |     private String userToken;
 33 |     private String prefix;
 34 |     private ZoneId zone = null;
 35 |     private OnlineStatus status;
 36 |     private boolean bot = false;
 37 |     
 38 |     public Config() throws Exception
 39 |     {
 40 |         List<String> lines = Files.readAllLines(Paths.get("config.txt"));
 41 |         for(String str : lines)
 42 |         {
 43 |             String[] parts = str.split("=",2);
 44 |             String key = parts[0].trim().toLowerCase();
 45 |             String value = parts.length>1 ? parts[1].trim() : null;
 46 |             switch(key) 
 47 |             {
 48 |                 case "token":
 49 |                     userToken = value;
 50 |                     break;
 51 |                 case "prefix":
 52 |                     if(value==null)
 53 |                     {
 54 |                         prefix = "";
 55 |                         LOG.warn("The prefix was defined as empty!");
 56 |                     }
 57 |                     else
 58 |                         prefix = value;
 59 |                     break;
 60 |                 case "timezone":
 61 |                     if(value==null)
 62 |                     {
 63 |                         zone = ZoneId.systemDefault();
 64 |                         LOG.warn("An empty timezone was provided; using the system default!");
 65 |                     }
 66 |                     else
 67 |                     {
 68 |                         try {
 69 |                             zone = ZoneId.of(value);
 70 |                         } catch(Exception e) {
 71 |                             zone = ZoneId.systemDefault();
 72 |                             LOG.warn("\""+value+"\" is not a valid timezone; using the system default!");
 73 |                         }
 74 |                     }
 75 |                     break;
 76 |                 case "status":
 77 |                     status = OnlineStatus.fromKey(value);
 78 |                     if(status == OnlineStatus.UNKNOWN)
 79 |                     {
 80 |                         status = OnlineStatus.IDLE;
 81 |                         LOG.warn("\""+value+"\" is not a valid status; using the default IDLE! Valid statuses are ONLINE, IDLE, DND, and INVISIBLE.");
 82 |                     }
 83 |                     break;
 84 |                 case "bot":
 85 |                     bot = "true".equalsIgnoreCase(value);
 86 |             }
 87 |         }
 88 |         if(userToken==null)
 89 |             throw new Exception("No token provided int he config file!");
 90 |         if(prefix==null)
 91 |             throw new Exception("No prefix provided in the config file!");
 92 |         if(zone==null)
 93 |         {
 94 |             zone = ZoneId.systemDefault();
 95 |             LOG.warn("No timezone provided; using the system default!");
 96 |         }
 97 |         if(status==null)
 98 |         {
 99 |             status = OnlineStatus.IDLE;
100 |             LOG.warn("No status provided; using IDLE!");
101 |         }
102 |     }
103 |     
104 |     public String getToken()
105 |     {
106 |         return userToken;
107 |     }
108 |     
109 |     public String getprefix()
110 |     {
111 |         return prefix;
112 |     }
113 |     
114 |     public ZoneId getZoneId()
115 |     {
116 |         return zone;
117 |     }
118 |     
119 |     public OnlineStatus getStatus()
120 |     {
121 |         return status;
122 |     }
123 |     
124 |     public boolean isForBot()
125 |     {
126 |         return bot;
127 |     }
128 | }
129 | 


--------------------------------------------------------------------------------
/src/jselfbot/entities/JagTagMethods.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * To change this license header, choose License Headers in Project Properties.
 3 |  * To change this template file, choose Tools | Templates
 4 |  * and open the template in the editor.
 5 |  */
 6 | package jselfbot.entities;
 7 | 
 8 | import java.awt.Color;
 9 | import java.time.OffsetDateTime;
10 | import java.util.Arrays;
11 | import java.util.Collection;
12 | import com.jagrosh.jagtag.Method;
13 | import net.dv8tion.jda.core.EmbedBuilder;
14 | 
15 | /**
16 |  *
17 |  * @author John Grosh (john.a.grosh@gmail.com)
18 |  */
19 | public class JagTagMethods {
20 |     
21 |     public static Collection<Method> getMethods()
22 |     {
23 |         return Arrays.asList(
24 |                 new Method("title", (env, in) -> {
25 |                     EmbedBuilder eb = env.get("builder");
26 |                     String[] parts = in[0].split("\\|",2);
27 |                     eb.setTitle(parts[0], parts.length>1 ? parts[1] : null);
28 |                     return "";}),
29 |                 
30 |                 new Method("author", (env, in) -> {
31 |                     EmbedBuilder eb = env.get("builder");
32 |                     String[] parts = in[0].split("\\|",3);
33 |                     eb.setAuthor(parts[0], parts.length>2 ? parts[2] : null, parts.length>1 ? parts[1] : null);
34 |                     return "";}),
35 |                 
36 |                 new Method("thumbnail", (env, in) -> {
37 |                     EmbedBuilder eb = env.get("builder");
38 |                     eb.setThumbnail(in[0]);
39 |                     return "";}),
40 |                 
41 |                 new Method("field", (env, in) -> {
42 |                     EmbedBuilder eb = env.get("builder");
43 |                     String[] parts = in[0].split("\\|",3);
44 |                     eb.addField(parts[0], parts[1], parts.length>2 ? parts[2].equalsIgnoreCase("true") : true);
45 |                     return "";}),
46 |                 
47 |                 new Method("image", (env, in) -> {
48 |                     EmbedBuilder eb = env.get("builder");
49 |                     eb.setImage(in[0]);
50 |                     return "";}),
51 |                 
52 |                 new Method("color", (env, in) -> {
53 |                     EmbedBuilder eb = env.get("builder");
54 |                     switch(in[0].toLowerCase()) {
55 |                         //standard
56 |                         case "red": eb.setColor(Color.RED); break;
57 |                         case "orange": eb.setColor(Color.ORANGE); break;
58 |                         case "yellow": eb.setColor(Color.YELLOW); break;
59 |                         case "green": eb.setColor(Color.GREEN); break;
60 |                         case "cyan": eb.setColor(Color.CYAN); break;
61 |                         case "blue": eb.setColor(Color.BLUE); break;
62 |                         case "magenta": eb.setColor(Color.MAGENTA); break;
63 |                         case "pink": eb.setColor(Color.PINK); break;
64 |                         case "black": eb.setColor(Color.decode("#000001")); break;
65 |                         case "dark_gray": 
66 |                         case "dark_grey": eb.setColor(Color.DARK_GRAY); break;
67 |                         case "gray":
68 |                         case "grey": eb.setColor(Color.GRAY); break;
69 |                         case "light_gray":
70 |                         case "light_grey": eb.setColor(Color.LIGHT_GRAY); break;
71 |                         case "white": eb.setColor(Color.WHITE); break;
72 |                         //discord
73 |                         case "blurple": eb.setColor(Color.decode("#7289DA")); break;
74 |                         case "greyple": eb.setColor(Color.decode("#99AAB5")); break;
75 |                         case "darktheme": eb.setColor(Color.decode("#2C2F33")); break;
76 |                         default: eb.setColor(Color.decode(in[0]));
77 |                     }
78 |                     return "";}),
79 |                 
80 |                 new Method("footer", (env, in) -> {
81 |                     EmbedBuilder eb = env.get("builder");
82 |                     String[] parts = in[0].split("\\|",2);
83 |                     eb.setFooter(parts[0], parts.length>1 ? parts[1] : null);
84 |                     return "";}),
85 |                 
86 |                 new Method("timestamp", (env) -> {
87 |                     EmbedBuilder eb = env.get("builder");
88 |                     eb.setTimestamp(OffsetDateTime.now());
89 |                     return "";}, (env, in) -> {
90 |                     EmbedBuilder eb = env.get("builder");
91 |                     eb.setTimestamp(OffsetDateTime.parse(in[0]));
92 |                     return "";})
93 |         );
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/src/jselfbot/entities/Todolist.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2016 John Grosh (jagrosh).
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *      http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | package jselfbot.entities;
 17 | 
 18 | import java.io.BufferedWriter;
 19 | import java.io.FileOutputStream;
 20 | import java.io.IOException;
 21 | import java.io.OutputStreamWriter;
 22 | import java.io.Writer;
 23 | import java.nio.file.Files;
 24 | import java.nio.file.Paths;
 25 | import java.util.ArrayList;
 26 | import java.util.List;
 27 | import java.util.stream.Collectors;
 28 | import jselfbot.utils.FormatUtil;
 29 | import org.json.JSONArray;
 30 | import org.json.JSONException;
 31 | import org.json.JSONObject;
 32 | import org.slf4j.Logger;
 33 | import org.slf4j.LoggerFactory;
 34 | 
 35 | /**
 36 |  *
 37 |  * @author John Grosh (jagrosh)
 38 |  */
 39 | public class Todolist {
 40 |     private final List<TodoItem> todolist;
 41 |     private final static String FILENAME = "todo.json";
 42 |     private final static Logger LOG = LoggerFactory.getLogger("Todo");
 43 |     
 44 |     public Todolist()
 45 |     {
 46 |         todolist = new ArrayList<>();
 47 |         JSONArray array;
 48 |         try {
 49 |             array = new JSONArray(FormatUtil.join(Files.readAllLines(Paths.get(FILENAME)), "\n"));
 50 |             for(int i=0; i<array.length(); i++)
 51 |                 todolist.add(new TodoItem(array.getJSONObject(i)));
 52 |             LOG.info("Successfully loaded "+todolist.size()+" todo entries!");
 53 |         } catch(IOException e) {
 54 |             LOG.warn(FILENAME+" was not found! This can be ignored if you haven't added any items to your todo list.");
 55 |         } catch(JSONException e) {
 56 |             LOG.error("The todo file, "+FILENAME+" is corrupted. Please fix the file before editing the todo list or the file will be overwritten.");
 57 |         }
 58 |     }
 59 |     
 60 |     private void write()
 61 |     {
 62 |         JSONArray array = new JSONArray();
 63 |         todolist.stream().forEach(todoitem -> array.put(todoitem.toJSON()));
 64 |         try (Writer out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(FILENAME), "UTF-8"))) {
 65 |             out.write(array.toString(2));
 66 |         }catch(IOException e) {
 67 |             LOG.error("Failed to save todolist to "+FILENAME);
 68 |         }
 69 |     }
 70 |     
 71 |     public void addItem(String content)
 72 |     {
 73 |         todolist.add(new TodoItem(content));
 74 |         write();
 75 |     }
 76 |     
 77 |     public void editItem(int index, String content)
 78 |     {
 79 |         todolist.get(index).editContent(content);
 80 |         write();
 81 |     }
 82 |     
 83 |     public TodoItem remove(int index)
 84 |     {
 85 |         TodoItem item = todolist.remove(index);
 86 |         write();
 87 |         return item;
 88 |     }
 89 |     
 90 |     public void complete(int index)
 91 |     {
 92 |         todolist.get(index).complete();
 93 |         write();
 94 |     }
 95 |     
 96 |     public List<TodoItem> getList()
 97 |     {
 98 |         return todolist;
 99 |     }
100 |     
101 |     public int clean()
102 |     {
103 |         List<TodoItem> del = todolist.stream().filter(item -> item.completed).collect(Collectors.toList());
104 |         todolist.removeAll(del);
105 |         write();
106 |         return del.size();
107 |     }
108 |     
109 |     public class TodoItem {
110 |         private String content;
111 |         private boolean completed;
112 |         private TodoItem(String content)
113 |         {
114 |             this.content=content;
115 |             this.completed = false;
116 |         }
117 |         private TodoItem(JSONObject obj)
118 |         {
119 |             this.content = obj.getString("c");
120 |             this.completed = obj.getBoolean("d");
121 |         }
122 |         private void editContent(String newcontent)
123 |         {
124 |             this.content = newcontent;
125 |         }
126 |         private void complete()
127 |         {
128 |             this.completed = true;
129 |         }
130 |         private JSONObject toJSON()
131 |         {
132 |             return new JSONObject().put("c",content).put("d", completed);
133 |         }
134 |         public String getContent()
135 |         {
136 |             return content;
137 |         }
138 |         @Override
139 |         public String toString()
140 |         {
141 |             return (completed ? "~~" : "") + content + (completed ? "~~" : "");
142 |         }
143 |     }
144 | }
145 | 


--------------------------------------------------------------------------------
/src/jselfbot/commands/AvatarCmd.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2016 John Grosh (jagrosh).
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *      http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | package jselfbot.commands;
 17 | 
 18 | import java.util.ArrayList;
 19 | import java.util.Collections;
 20 | import java.util.List;
 21 | import jselfbot.Command;
 22 | import net.dv8tion.jda.core.JDA;
 23 | import net.dv8tion.jda.core.entities.Guild;
 24 | import net.dv8tion.jda.core.entities.User;
 25 | import net.dv8tion.jda.core.entities.impl.JDAImpl;
 26 | import net.dv8tion.jda.core.entities.impl.UserImpl;
 27 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
 28 | 
 29 | /**
 30 |  *
 31 |  * @author John Grosh (jagrosh)
 32 |  */
 33 | public class AvatarCmd extends Command {
 34 | 
 35 |     public AvatarCmd()
 36 |     {
 37 |         this.name = "avatar";
 38 |         this.description = "shows a user's (or your) avatar";
 39 |         this.arguments = "[user]";
 40 |         this.type = Type.EDIT_ORIGINAL;
 41 |     }
 42 |     
 43 |     @Override
 44 |     protected void execute(String args, MessageReceivedEvent event) {
 45 |         if(args==null || args.isEmpty())
 46 |         {
 47 |             reply(event.getJDA().getSelfUser().getEffectiveAvatarUrl()+"?size=1024", event);
 48 |         }
 49 |         else
 50 |         {
 51 |             Guild g;
 52 |             try {
 53 |                 g = event.getJDA().getGuildById(args);
 54 |             } catch(Exception e) {
 55 |                 g = null;
 56 |             }
 57 |             if(g!=null)
 58 |             {
 59 |                 reply(g.getIconUrl()+"?size=1024"+(g.getSplashId()==null ? "" : "\n"+g.getSplashUrl()+"?size=1024"),event);
 60 |                 return;
 61 |             }
 62 |             List<User> users = findUsers(args, event.getJDA());
 63 |             if(users.isEmpty())
 64 |                 tempReply("No users found!", event);
 65 |             else
 66 |                 reply(users.get(0).getEffectiveAvatarUrl()+"?size=1024", event);
 67 |         }
 68 |     }
 69 |     
 70 |     public final static String USER_MENTION = "<@!?(\\d{17,22})>";
 71 |     public final static String DISCORD_ID = "\\d{17,22}";
 72 |     
 73 |     public static List<User> findUsers(String query, JDA jda)
 74 |     {
 75 |         String id;
 76 |         String discrim = null;
 77 |         if(query.matches(USER_MENTION))
 78 |         {
 79 |             id = query.replaceAll(USER_MENTION, "$1");
 80 |             if(id.equals("1"))
 81 |             {
 82 |                 UserImpl clyde = new UserImpl(1L, (JDAImpl) jda);
 83 |                 clyde.setDiscriminator("0000");
 84 |                 clyde.setBot(true);
 85 |                 clyde.setName("Clyde");
 86 |                 return Collections.singletonList(clyde);
 87 |             }
 88 |             User u = jda.getUserById(id);
 89 |             if(u!=null)
 90 |                 return Collections.singletonList(u);
 91 |         }
 92 |         else if(query.matches(DISCORD_ID))
 93 |         {
 94 |             id = query;
 95 |             User u = jda.getUserById(id);
 96 |             if(u!=null)
 97 |                 return Collections.singletonList(u);
 98 |         }
 99 |         else if(query.matches("^.*#\\d{4}$"))
100 |         {
101 |             discrim = query.substring(query.length()-4);
102 |             query = query.substring(0,query.length()-5).trim();
103 |         }
104 |         ArrayList<User> exact = new ArrayList<>();
105 |         ArrayList<User> wrongcase = new ArrayList<>();
106 |         ArrayList<User> startswith = new ArrayList<>();
107 |         ArrayList<User> contains = new ArrayList<>();
108 |         String lowerQuery = query.toLowerCase();
109 |         for(User u: jda.getUsers())
110 |         {
111 |             if(discrim!=null && !u.getDiscriminator().equals(discrim))
112 |                 continue;
113 |             if(u.getName().equals(query))
114 |                 exact.add(u);
115 |             else if (exact.isEmpty() && u.getName().equalsIgnoreCase(query))
116 |                 wrongcase.add(u);
117 |             else if (wrongcase.isEmpty() && u.getName().toLowerCase().startsWith(lowerQuery))
118 |                 startswith.add(u);
119 |             else if (startswith.isEmpty() && u.getName().toLowerCase().contains(lowerQuery))
120 |                 contains.add(u);
121 |         }
122 |         if(!exact.isEmpty())
123 |             return exact;
124 |         if(!wrongcase.isEmpty())
125 |             return wrongcase;
126 |         if(!startswith.isEmpty())
127 |             return startswith;
128 |         return contains;
129 |     }
130 | }
131 | 


--------------------------------------------------------------------------------
/src/jselfbot/utils/WrapUtil.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * To change this license header, choose License Headers in Project Properties.
  3 |  * To change this template file, choose Tools | Templates
  4 |  * and open the template in the editor.
  5 |  */
  6 | package jselfbot.utils;
  7 | 
  8 | import java.awt.FontMetrics;
  9 | import java.util.ArrayList;
 10 | import java.util.Iterator;
 11 | import java.util.List;
 12 | 
 13 | /**
 14 |  * Globally available utility classes, mostly for string manipulation.
 15 |  * 
 16 |  * @author Jim Menard, <a href="mailto:jimm@io.com">jimm@io.com</a>
 17 |  */
 18 | public class WrapUtil {
 19 |   /**
 20 |    * Returns an array of strings, one for each line in the string after it has
 21 |    * been wrapped to fit lines of <var>maxWidth</var>. Lines end with any of
 22 |    * cr, lf, or cr lf. A line ending at the end of the string will not output a
 23 |    * further, empty string.
 24 |    * <p>
 25 |    * This code assumes <var>str</var> is not <code>null</code>.
 26 |    * 
 27 |    * @param str
 28 |    *          the string to split
 29 |    * @param fm
 30 |    *          needed for string width calculations
 31 |    * @param maxWidth
 32 |    *          the max line width, in points
 33 |    * @return a non-empty list of strings
 34 |    */
 35 |   public static List wrap(String str, FontMetrics fm, int maxWidth) {
 36 |     List lines = splitIntoLines(str);
 37 |     if (lines.isEmpty())
 38 |       return lines;
 39 | 
 40 |     ArrayList strings = new ArrayList();
 41 |     for (Iterator iter = lines.iterator(); iter.hasNext();)
 42 |       wrapLineInto((String) iter.next(), strings, fm, maxWidth);
 43 |     return strings;
 44 |   }
 45 | 
 46 |   /**
 47 |    * Given a line of text and font metrics information, wrap the line and add
 48 |    * the new line(s) to <var>list</var>.
 49 |    * 
 50 |    * @param line
 51 |    *          a line of text
 52 |    * @param list
 53 |    *          an output list of strings
 54 |    * @param fm
 55 |    *          font metrics
 56 |    * @param maxWidth
 57 |    *          maximum width of the line(s)
 58 |    */
 59 |   public static void wrapLineInto(String line, List list, FontMetrics fm, int maxWidth) {
 60 |     int len = line.length();
 61 |     int width;
 62 |     while (len > 0 && (width = fm.stringWidth(line)) > maxWidth) {
 63 |       // Guess where to split the line. Look for the next space before
 64 |       // or after the guess.
 65 |       int guess = len * maxWidth / width;
 66 |       String before = line.substring(0, guess).trim();
 67 | 
 68 |       width = fm.stringWidth(before);
 69 |       int pos;
 70 |       if (width > maxWidth) // Too long
 71 |         pos = findBreakBefore(line, guess);
 72 |       else { // Too short or possibly just right
 73 |         pos = findBreakAfter(line, guess);
 74 |         if (pos != -1) { // Make sure this doesn't make us too long
 75 |           before = line.substring(0, pos).trim();
 76 |           if (fm.stringWidth(before) > maxWidth)
 77 |             pos = findBreakBefore(line, guess);
 78 |         }
 79 |       }
 80 |       if (pos == -1)
 81 |         pos = guess; // Split in the middle of the word
 82 | 
 83 |       list.add(line.substring(0, pos).trim());
 84 |       line = line.substring(pos).trim();
 85 |       len = line.length();
 86 |     }
 87 |     if (len > 0)
 88 |       list.add(line);
 89 |   }
 90 | 
 91 |   /**
 92 |    * Returns the index of the first whitespace character or '-' in <var>line</var>
 93 |    * that is at or before <var>start</var>. Returns -1 if no such character is
 94 |    * found.
 95 |    * 
 96 |    * @param line
 97 |    *          a string
 98 |    * @param start
 99 |    *          where to star looking
100 |      * @return 
101 |    */
102 |   public static int findBreakBefore(String line, int start) {
103 |     for (int i = start; i >= 0; --i) {
104 |       char c = line.charAt(i);
105 |       if (Character.isWhitespace(c) || c == '-')
106 |         return i;
107 |     }
108 |     return -1;
109 |   }
110 | 
111 |   /**
112 |    * Returns the index of the first whitespace character or '-' in <var>line</var>
113 |    * that is at or after <var>start</var>. Returns -1 if no such character is
114 |    * found.
115 |    * 
116 |    * @param line
117 |    *          a string
118 |    * @param start
119 |    *          where to star looking
120 |      * @return 
121 |    */
122 |   public static int findBreakAfter(String line, int start) {
123 |     int len = line.length();
124 |     for (int i = start; i < len; ++i) {
125 |       char c = line.charAt(i);
126 |       if (Character.isWhitespace(c) || c == '-')
127 |         return i;
128 |     }
129 |     return -1;
130 |   }
131 |   /**
132 |    * Returns an array of strings, one for each line in the string. Lines end
133 |    * with any of cr, lf, or cr lf. A line ending at the end of the string will
134 |    * not output a further, empty string.
135 |    * <p>
136 |    * This code assumes <var>str</var> is not <code>null</code>.
137 |    * 
138 |    * @param str
139 |    *          the string to split
140 |    * @return a non-empty list of strings
141 |    */
142 |   public static List splitIntoLines(String str) {
143 |     ArrayList strings = new ArrayList();
144 | 
145 |     int len = str.length();
146 |     if (len == 0) {
147 |       strings.add("");
148 |       return strings;
149 |     }
150 | 
151 |     int lineStart = 0;
152 | 
153 |     for (int i = 0; i < len; ++i) {
154 |       char c = str.charAt(i);
155 |       if (c == '\r') {
156 |         int newlineLength = 1;
157 |         if ((i + 1) < len && str.charAt(i + 1) == '\n')
158 |           newlineLength = 2;
159 |         strings.add(str.substring(lineStart, i));
160 |         lineStart = i + newlineLength;
161 |         if (newlineLength == 2) // skip \n next time through loop
162 |           ++i;
163 |       } else if (c == '\n') {
164 |         strings.add(str.substring(lineStart, i));
165 |         lineStart = i + 1;
166 |       }
167 |     }
168 |     if (lineStart < len)
169 |       strings.add(str.substring(lineStart));
170 | 
171 |     return strings;
172 |   }
173 | 
174 | }
175 | 


--------------------------------------------------------------------------------
/src/jselfbot/commands/QuoteCmd.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2016 John Grosh (jagrosh).
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *      http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | package jselfbot.commands;
 17 | 
 18 | import jselfbot.Command;
 19 | import net.dv8tion.jda.core.EmbedBuilder;
 20 | import net.dv8tion.jda.core.JDA;
 21 | import net.dv8tion.jda.core.entities.Member;
 22 | import net.dv8tion.jda.core.entities.Message;
 23 | import net.dv8tion.jda.core.entities.MessageChannel;
 24 | import net.dv8tion.jda.core.entities.User;
 25 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
 26 | 
 27 | /**
 28 |  *
 29 |  * @author John Grosh (jagrosh)
 30 |  */
 31 | public class QuoteCmd extends Command {
 32 | 
 33 |     public QuoteCmd()
 34 |     {
 35 |         this.name = "quote";
 36 |         this.description = "quotes a message";
 37 |         this.arguments = "<message id> [channel mention or id] [text]";
 38 |     }
 39 |     
 40 |     @Override
 41 |     protected void execute(String args, MessageReceivedEvent event) {
 42 |         String[] parts = args.split("\\s+", 2);
 43 |         String id1 = parts[0].replaceAll("<#(\\d+)>", "$1");
 44 |         if(!isId(id1))
 45 |         {
 46 |             tempReply("`"+id1+"` is not a valid message or channel ID", event);
 47 |             return;
 48 |         }
 49 |         MessageChannel channel = resolveChannel(id1, event.getJDA());
 50 |         String messageId;
 51 |         String followingText = null;
 52 |         if(channel != null) //channel id found, need a message id now
 53 |         {
 54 |             if(parts.length==1)
 55 |             {
 56 |                 tempReply("Channel provided but no message id!", event);
 57 |                 return;
 58 |             }
 59 |             parts = parts[1].split("\\s+",2);
 60 |             if(!isId(parts[0]))
 61 |             {
 62 |                 tempReply("`"+parts[0]+"` is not a valid message ID", event);
 63 |                 return;
 64 |             }
 65 |             messageId = parts[0];
 66 |             followingText = parts.length>1 ? parts[1] : null;
 67 |         }
 68 |         else
 69 |         {
 70 |             messageId = id1;
 71 |             if(parts.length>1)
 72 |             {
 73 |                 String[] parts2 = parts[1].split("\\s+", 2);
 74 |                 String id2 = parts2[0].replaceAll("<#(\\d+)>", "$1");
 75 |                 channel = resolveChannel(id2, event.getJDA());
 76 |                 if(channel == null)
 77 |                     followingText = parts[1];
 78 |                 else
 79 |                     followingText = parts2.length>1 ? parts2[1] : null;
 80 |             }
 81 |         }
 82 |         String follow = followingText;
 83 |         if(channel==null)
 84 |             channel = event.getChannel();
 85 |         try
 86 |         {
 87 |             String foot = channel.equals(event.getChannel()) ? "" : " in #"+channel.getName();
 88 |             channel.getHistoryAround(messageId, 2).queue(
 89 |                     mh -> {
 90 |                         if(mh.getRetrievedHistory().isEmpty())
 91 |                         {
 92 |                             tempReply("No message history around `"+messageId+"`", event);
 93 |                             return;
 94 |                         }
 95 |                         Message msg = mh.getRetrievedHistory().size()==1 || mh.getRetrievedHistory().size()==2 ? mh.getRetrievedHistory().get(0) : mh.getRetrievedHistory().get(1);
 96 |                         EmbedBuilder builder = new EmbedBuilder();
 97 |                         builder.setAuthor(msg.getAuthor().getName()+" #"+msg.getAuthor().getDiscriminator(), null, 
 98 |                                 msg.getAuthor().getEffectiveAvatarUrl());
 99 |                         if(msg.getGuild()!=null)
100 |                         {
101 |                             Member member = msg.getGuild().getMemberById(msg.getAuthor().getId());
102 |                             if(member!=null)
103 |                                 builder.setColor(member.getColor());
104 |                         }
105 |                         if(!msg.getAttachments().isEmpty() && msg.getAttachments().get(0).isImage())
106 |                             builder.setImage(msg.getAttachments().get(0).getUrl());
107 |                         if(msg.isEdited())
108 |                         {
109 |                             builder.setFooter("Edited"+foot, null);
110 |                             builder.setTimestamp(msg.getEditedTime());
111 |                         }
112 |                         else
113 |                         {
114 |                             builder.setFooter("Sent"+foot, null);
115 |                             builder.setTimestamp(msg.getCreationTime());
116 |                         }
117 |                         builder.setDescription(msg.getRawContent());
118 |                         reply(builder.build(), event, follow==null ? null : s -> event.getChannel().sendMessage(follow).queue());
119 |                     }, 
120 |                     f -> tempReply("Failed to retrieve history around `"+messageId+"`", event));
121 |         }
122 |         catch(Exception e)
123 |         {
124 |             tempReply("Could not retrieve history: "+e, event);
125 |         }
126 |     }
127 |     
128 |     private static MessageChannel resolveChannel(String id, JDA jda)
129 |     {
130 |         MessageChannel mc = jda.getTextChannelById(id);
131 |         if(mc!=null)
132 |             return mc;
133 |         mc = jda.getPrivateChannelById(id);
134 |         if(mc!=null)
135 |             return mc;
136 |         User u = jda.getUserById(id);
137 |         if(u!=null)
138 |             return u.openPrivateChannel().complete();
139 |         return null;
140 |     }
141 |     
142 |     private static boolean isId(String id)
143 |     {
144 |         return id.matches("\\d{17,22}");
145 |     }
146 | }
147 | 


--------------------------------------------------------------------------------
/src/jselfbot/Bot.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2016 John Grosh (jagrosh).
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *      http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | package jselfbot;
 17 | 
 18 | import jselfbot.commands.*;
 19 | import jselfbot.entities.Config;
 20 | import jselfbot.entities.Emojis;
 21 | import jselfbot.entities.Todolist;
 22 | import net.dv8tion.jda.core.EmbedBuilder;
 23 | import net.dv8tion.jda.core.MessageBuilder;
 24 | import net.dv8tion.jda.core.events.ReadyEvent;
 25 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
 26 | import net.dv8tion.jda.core.hooks.ListenerAdapter;
 27 | import org.slf4j.LoggerFactory;
 28 | 
 29 | /**
 30 |  *
 31 |  * @author John Grosh (jagrosh)
 32 |  */
 33 | public class Bot extends ListenerAdapter {
 34 |     private final String prefix;
 35 |     private final String prefixLower;
 36 |     private final Command[] commands;
 37 |     private final Emojis emojis;
 38 |     private final Todolist todo;
 39 |     
 40 |     public Bot(Config config)
 41 |     {
 42 |         prefix = config.getprefix();
 43 |         prefixLower = prefix.toLowerCase();
 44 |         emojis = new Emojis();
 45 |         todo = new Todolist();
 46 |         commands = new Command[]{
 47 |             new AvatarCmd(),
 48 |             new BashCmd(),
 49 |             new ClearCmd(),
 50 |             new DeleteCmd(emojis),
 51 |             new DiscrimCmd(),
 52 |             new EmbedCmd(),
 53 |             new EmoteCmd(),
 54 |             new EvalCmd(),
 55 |             new GameCmd(),
 56 |             new GoogleCmd(),
 57 |             new ListCmd(emojis),
 58 |             new MeCmd(),
 59 |             new PingCmd(),
 60 |             new PollCmd(),
 61 |             new QuoteCmd(),
 62 |             new SetCmd(emojis),
 63 |             new SpoilerCmd(),
 64 |             new TimeCmd(config.getZoneId()),
 65 |             new TodoCmd(todo)
 66 |         };
 67 |     }
 68 | 
 69 |     @Override
 70 |     public void onReady(ReadyEvent event) {
 71 |         LoggerFactory.getLogger("Selfbot").info("Successfully logged in as "+event.getJDA().getSelfUser().getName()
 72 |                 +"#"+event.getJDA().getSelfUser().getDiscriminator()+"!\nYou are currently in "+event.getJDA().getGuilds().size()
 73 |                 +" guilds!\nType "+prefix+"help in Discord to get started!");
 74 |     }
 75 |     
 76 |     @Override
 77 |     public void onMessageReceived(MessageReceivedEvent event) {
 78 |         // the selfbot only replies to the user account it is running on
 79 |         if (!event.getAuthor().equals(event.getJDA().getSelfUser()))
 80 |             return;
 81 | 
 82 |         boolean isCommand = false;
 83 |         if(event.getMessage().getRawContent().toLowerCase().startsWith(prefixLower))
 84 |         {
 85 |             String[] parts = event.getMessage().getRawContent()
 86 |                     .substring(prefixLower.length()).trim().split("\\s+",2);
 87 |             if(parts.length<2)
 88 |                 parts = new String[]{parts[0], ""};
 89 |             
 90 |             if("help".equalsIgnoreCase(parts[0]))
 91 |             {
 92 |                 event.getMessage().delete().queue();
 93 |                 EmbedBuilder builder = new EmbedBuilder();
 94 |                 builder.setAuthor(event.getJDA().getSelfUser().getName()+" Self-Help", null, 
 95 |                         event.getJDA().getSelfUser().getAvatarUrl()==null ? event.getJDA().getSelfUser().getDefaultAvatarUrl() : event.getJDA().getSelfUser().getAvatarUrl());
 96 |                 if(event.getGuild()!=null)
 97 |                     builder.setColor(event.getGuild().getSelfMember().getColor());
 98 |                 StringBuilder sbuilder = new StringBuilder("Commands:");
 99 |                 for(Command command: commands)
100 |                 {
101 |                     sbuilder.append("\n`").append(prefix).append(command.name);
102 |                     if(command.arguments!=null)
103 |                         sbuilder.append(" ").append(command.arguments);
104 |                     sbuilder.append("` ").append(command.description);
105 |                 }
106 |                 builder.setDescription(sbuilder.toString());
107 |                 builder.setFooter("JSelfbot v"+Constants.VERSION, null);
108 |                 event.getChannel().sendMessage(new MessageBuilder().setEmbed(builder.build()).build()).queue();
109 |             }
110 |             else
111 |                 for(Command command : commands)
112 |                     if(command.name.equalsIgnoreCase(parts[0]))
113 |                     {
114 |                         isCommand = true;
115 |                         command.run(parts[1], event);
116 |                     }
117 |         }
118 |         if(!isCommand)
119 |         {
120 |             StringBuilder builder = new StringBuilder();
121 |             String content = event.getMessage().getRawContent();
122 |             while(true)
123 |             {
124 |                 int index1 = content.indexOf(":");
125 |                 int index2 = content.indexOf(":", index1+1);
126 |                 if(index2==-1)
127 |                     break;
128 |                 String emoji = emojis.getEmoji(content.substring(index1+1, index2));
129 |                 if(emoji==null)
130 |                 {
131 |                     builder.append(content.substring(0, index2));
132 |                     content = content.substring(index2);
133 |                 }
134 |                 else
135 |                 {
136 |                     builder.append(content.substring(0, index1));
137 |                     builder.append(emoji);
138 |                     content = content.substring(index2+1);
139 |                 }
140 |             }
141 |             builder.append(content);
142 |             content = builder.toString();
143 |             if(!content.equals(event.getMessage().getRawContent()))
144 |                 event.getMessage().editMessage(content).queue();
145 |         }
146 |     }
147 |     
148 | }
149 | 


--------------------------------------------------------------------------------
/src/jselfbot/commands/TodoCmd.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * To change this license header, choose License Headers in Project Properties.
  3 |  * To change this template file, choose Tools | Templates
  4 |  * and open the template in the editor.
  5 |  */
  6 | package jselfbot.commands;
  7 | 
  8 | import jselfbot.Command;
  9 | import jselfbot.entities.Todolist;
 10 | import jselfbot.entities.Todolist.TodoItem;
 11 | import net.dv8tion.jda.core.EmbedBuilder;
 12 | import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
 13 | 
 14 | /**
 15 |  *
 16 |  * @author John Grosh (john.a.grosh@gmail.com)
 17 |  */
 18 | public class TodoCmd extends Command {
 19 | 
 20 |     private final Todolist todo;
 21 |     public TodoCmd(Todolist todo)
 22 |     {
 23 |         this.todo = todo;
 24 |         this.name = "todo";
 25 |         this.description = "manages your todo list";
 26 |         this.type = Type.DELETE_AND_RESEND;
 27 |     }
 28 |     
 29 |     @Override
 30 |     protected void execute(String args, MessageReceivedEvent event) {
 31 |         if(args==null || args.isEmpty() || args.equalsIgnoreCase("help"))
 32 |         {
 33 |             EmbedBuilder builder = new EmbedBuilder();
 34 |             if(event.getGuild()!=null)
 35 |                 builder.setColor(event.getGuild().getSelfMember().getColor());
 36 |             builder.setAuthor("\uD83D\uDCDD Todo Help:", null, null);
 37 |             builder.setDescription("`todo help` this message"
 38 |                     + "\n`todo list` views your todo list"
 39 |                     + "\n`todo add <content>` adds a new item"
 40 |                     + "\n`todo edit <number> <newcontent>` edits an item"
 41 |                     + "\n`todo checkoff <number>` marks an item as completed"
 42 |                     + "\n`todo delete <number>` removes an item from the list"
 43 |                     + "\n`todo clean` removes all completed items from the list");
 44 |             reply(builder.build(), event);
 45 |             return;
 46 |         }
 47 |         String[] parts = args.split("\\s+", 2);
 48 |         switch(parts[0].toLowerCase()) {
 49 |             case "list":
 50 |                 if(todo.getList().isEmpty())
 51 |                     tempReply("Your todo list is empty!", event);
 52 |                 else
 53 |                 {
 54 |                     EmbedBuilder builder = new EmbedBuilder();
 55 |                     if(event.getGuild()!=null)
 56 |                         builder.setColor(event.getGuild().getSelfMember().getColor());
 57 |                     builder.setAuthor("\uD83D\uDCDD Todo List:", null, null);
 58 |                     
 59 |                     StringBuilder sbuilder = new StringBuilder();
 60 |                     for(int i=0; i<todo.getList().size(); i++)
 61 |                     {
 62 |                         String next = "\n`"+(i+1)+".` "+todo.getList().get(i).toString();
 63 |                         if(sbuilder.length()+next.length()>1985)
 64 |                         {
 65 |                             reply(builder.setDescription(sbuilder.toString().trim()).build(),event);
 66 |                             builder.setAuthor(null,null,null);
 67 |                             sbuilder = new StringBuilder();
 68 |                         }
 69 |                         sbuilder.append(next);
 70 |                     }
 71 |                     builder.setDescription(sbuilder.toString().trim());
 72 |                     reply(builder.build(), event);
 73 |                 }
 74 |                 break;
 75 |             case "remove":
 76 |             case "delete":
 77 |                 if(parts.length<2)
 78 |                     tempReply("Please include a number to remove!", event);
 79 |                 else try {
 80 |                     int index = Integer.parseInt(parts[1]);
 81 |                     if(index<1 || index>todo.getList().size())
 82 |                         tempReply("Index cannot be less than 1 nor greater than "+todo.getList().size(),event);
 83 |                     else
 84 |                     {
 85 |                         String content = todo.remove(index-1).getContent();
 86 |                         tempReply("Completed item "+index+" (`"+content+"`)",event);
 87 |                     }
 88 |                 } catch(NumberFormatException e) {
 89 |                     tempReply("`"+parts[1]+"` is not a valid integer", event);
 90 |                 }
 91 |                 break;
 92 |             case "checkoff":
 93 |             case "check":
 94 |                 if(parts.length<2)
 95 |                     tempReply("Please include a number to checkoff!", event);
 96 |                 else try {
 97 |                     int index = Integer.parseInt(parts[1]);
 98 |                     if(index<1 || index>todo.getList().size())
 99 |                         tempReply("Index cannot be less than 1 nor greater than "+todo.getList().size(),event);
100 |                     else
101 |                     {
102 |                         todo.complete(index-1);
103 |                         tempReply("Completed item "+index+" (`"+todo.getList().get(index-1).getContent()+"`)",event);
104 |                     }
105 |                 } catch(NumberFormatException e) {
106 |                     tempReply("`"+parts[1]+"` is not a valid integer", event);
107 |                 }
108 |                 break;
109 |             case "add":
110 |                 if(parts.length<2)
111 |                     tempReply("Please include content for the todo item!", event);
112 |                 else
113 |                 {
114 |                     todo.addItem(parts[1]);
115 |                     tempReply("Added `"+parts[1]+"` to the todo list!", event);
116 |                 }
117 |                 break;
118 |             case "edit":
119 |                 if(parts.length<2)
120 |                     tempReply("Please include a todo item number and the new content", event);
121 |                 else
122 |                 {
123 |                     String[] parts2 = parts[1].split("\\s+", 2);
124 |                     if(parts2.length<2)
125 |                         tempReply("Please include a todo item number and the new content", event);
126 |                     else
127 |                     {
128 |                         try {
129 |                             int index = Integer.parseInt(parts2[0]);
130 |                             if(index<1 || index>todo.getList().size())
131 |                                 tempReply("Index cannot be less than 1 nor greater than "+todo.getList().size(),event);
132 |                             else
133 |                             {
134 |                                 todo.editItem(index-1, parts2[1]);
135 |                                 tempReply("Edited item "+index+" to `"+parts2[1]+"`",event);
136 |                             }
137 |                         } catch(NumberFormatException e) {
138 |                             tempReply("`"+parts2[0]+"` is not a valid integer", event);
139 |                         }
140 |                     }
141 |                 }
142 |                 break;
143 |             case "clean":
144 |                 tempReply("Removed "+todo.clean()+" completed items from the todo list!", event);
145 |                 break;
146 |             default:
147 |                 tempReply("Unknown todo command `"+parts[0]+"`; see `todo help` for commands.", event);
148 |         }
149 |     }
150 |     
151 | }
152 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "{}"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright 2017 John Grosh
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 


--------------------------------------------------------------------------------
/src/jselfbot/entities/AnimatedGifEncoder.java:
--------------------------------------------------------------------------------
   1 | /*
   2 |  * To change this license header, choose License Headers in Project Properties.
   3 |  * To change this template file, choose Tools | Templates
   4 |  * and open the template in the editor.
   5 |  */
   6 | package jselfbot.entities;
   7 | 
   8 | import java.io.*;
   9 | import java.awt.*;
  10 | import java.awt.image.*;
  11 | 
  12 | /**
  13 |  * Class AnimatedGifEncoder - Encodes a GIF file consisting of one or more
  14 |  * frames.
  15 |  * 
  16 |  * <pre>
  17 |  *  Example:
  18 |  *     AnimatedGifEncoder e = new AnimatedGifEncoder();
  19 |  *     e.start(outputFileName);
  20 |  *     e.setDelay(1000);   // 1 frame per sec
  21 |  *     e.addFrame(image1);
  22 |  *     e.addFrame(image2);
  23 |  *     e.finish();
  24 |  * </pre>
  25 |  * 
  26 |  * No copyright asserted on the source code of this class. May be used for any
  27 |  * purpose, however, refer to the Unisys LZW patent for restrictions on use of
  28 |  * the associated LZWEncoder class. Please forward any corrections to
  29 |  * kweiner@fmsware.com.
  30 |  * 
  31 |  * @author Kevin Weiner, FM Software
  32 |  * @version 1.03 November 2003
  33 |  * 
  34 |  */
  35 | 
  36 | public class AnimatedGifEncoder {
  37 | 
  38 |   protected int width; // image size
  39 | 
  40 |   protected int height;
  41 | 
  42 |   protected Color transparent = null; // transparent color if given
  43 | 
  44 |   protected int transIndex; // transparent index in color table
  45 | 
  46 |   protected int repeat = -1; // no repeat
  47 | 
  48 |   protected int delay = 0; // frame delay (hundredths)
  49 | 
  50 |   protected boolean started = false; // ready to output frames
  51 | 
  52 |   protected OutputStream out;
  53 | 
  54 |   protected BufferedImage image; // current frame
  55 | 
  56 |   protected byte[] pixels; // BGR byte array from frame
  57 | 
  58 |   protected byte[] indexedPixels; // converted frame indexed to palette
  59 | 
  60 |   protected int colorDepth; // number of bit planes
  61 | 
  62 |   protected byte[] colorTab; // RGB palette
  63 | 
  64 |   protected boolean[] usedEntry = new boolean[256]; // active palette entries
  65 | 
  66 |   protected int palSize = 7; // color table size (bits-1)
  67 | 
  68 |   protected int dispose = -1; // disposal code (-1 = use default)
  69 | 
  70 |   protected boolean closeStream = false; // close stream when finished
  71 | 
  72 |   protected boolean firstFrame = true;
  73 | 
  74 |   protected boolean sizeSet = false; // if false, get size from first frame
  75 | 
  76 |   protected int sample = 10; // default sample interval for quantizer
  77 | 
  78 |   /**
  79 |    * Sets the delay time between each frame, or changes it for subsequent frames
  80 |    * (applies to last frame added).
  81 |    * 
  82 |    * @param ms
  83 |    *          int delay time in milliseconds
  84 |    */
  85 |   public void setDelay(int ms) {
  86 |     delay = Math.round(ms / 10.0f);
  87 |   }
  88 | 
  89 |   /**
  90 |    * Sets the GIF frame disposal code for the last added frame and any
  91 |    * subsequent frames. Default is 0 if no transparent color has been set,
  92 |    * otherwise 2.
  93 |    * 
  94 |    * @param code
  95 |    *          int disposal code.
  96 |    */
  97 |   public void setDispose(int code) {
  98 |     if (code >= 0) {
  99 |       dispose = code;
 100 |     }
 101 |   }
 102 | 
 103 |   /**
 104 |    * Sets the number of times the set of GIF frames should be played. Default is
 105 |    * 1; 0 means play indefinitely. Must be invoked before the first image is
 106 |    * added.
 107 |    * 
 108 |    * @param iter
 109 |    *          int number of iterations.
 110 |    * @return
 111 |    */
 112 |   public void setRepeat(int iter) {
 113 |     if (iter >= 0) {
 114 |       repeat = iter;
 115 |     }
 116 |   }
 117 | 
 118 |   /**
 119 |    * Sets the transparent color for the last added frame and any subsequent
 120 |    * frames. Since all colors are subject to modification in the quantization
 121 |    * process, the color in the final palette for each frame closest to the given
 122 |    * color becomes the transparent color for that frame. May be set to null to
 123 |    * indicate no transparent color.
 124 |    * 
 125 |    * @param c
 126 |    *          Color to be treated as transparent on display.
 127 |    */
 128 |   public void setTransparent(Color c) {
 129 |     transparent = c;
 130 |   }
 131 | 
 132 |   /**
 133 |    * Adds next GIF frame. The frame is not written immediately, but is actually
 134 |    * deferred until the next frame is received so that timing data can be
 135 |    * inserted. Invoking <code>finish()</code> flushes all frames. If
 136 |    * <code>setSize</code> was not invoked, the size of the first image is used
 137 |    * for all subsequent frames.
 138 |    * 
 139 |    * @param im
 140 |    *          BufferedImage containing frame to write.
 141 |    * @return true if successful.
 142 |    */
 143 |   public boolean addFrame(BufferedImage im) {
 144 |     if ((im == null) || !started) {
 145 |       return false;
 146 |     }
 147 |     boolean ok = true;
 148 |     try {
 149 |       if (!sizeSet) {
 150 |         // use first frame's size
 151 |         setSize(im.getWidth(), im.getHeight());
 152 |       }
 153 |       image = im;
 154 |       getImagePixels(); // convert to correct format if necessary
 155 |       analyzePixels(); // build color table & map pixels
 156 |       if (firstFrame) {
 157 |         writeLSD(); // logical screen descriptior
 158 |         writePalette(); // global color table
 159 |         if (repeat >= 0) {
 160 |           // use NS app extension to indicate reps
 161 |           writeNetscapeExt();
 162 |         }
 163 |       }
 164 |       writeGraphicCtrlExt(); // write graphic control extension
 165 |       writeImageDesc(); // image descriptor
 166 |       if (!firstFrame) {
 167 |         writePalette(); // local color table
 168 |       }
 169 |       writePixels(); // encode and write pixel data
 170 |       firstFrame = false;
 171 |     } catch (IOException e) {
 172 |       ok = false;
 173 |     }
 174 | 
 175 |     return ok;
 176 |   }
 177 | 
 178 |   /**
 179 |    * Flushes any pending data and closes output file. If writing to an
 180 |    * OutputStream, the stream is not closed.
 181 |    */
 182 |   public boolean finish() {
 183 |     if (!started)
 184 |       return false;
 185 |     boolean ok = true;
 186 |     started = false;
 187 |     try {
 188 |       out.write(0x3b); // gif trailer
 189 |       out.flush();
 190 |       if (closeStream) {
 191 |         out.close();
 192 |       }
 193 |     } catch (IOException e) {
 194 |       ok = false;
 195 |     }
 196 | 
 197 |     // reset for subsequent use
 198 |     transIndex = 0;
 199 |     out = null;
 200 |     image = null;
 201 |     pixels = null;
 202 |     indexedPixels = null;
 203 |     colorTab = null;
 204 |     closeStream = false;
 205 |     firstFrame = true;
 206 | 
 207 |     return ok;
 208 |   }
 209 | 
 210 |   /**
 211 |    * Sets frame rate in frames per second. Equivalent to
 212 |    * <code>setDelay(1000/fps)</code>.
 213 |    * 
 214 |    * @param fps
 215 |    *          float frame rate (frames per second)
 216 |    */
 217 |   public void setFrameRate(float fps) {
 218 |     if (fps != 0f) {
 219 |       delay = Math.round(100f / fps);
 220 |     }
 221 |   }
 222 | 
 223 |   /**
 224 |    * Sets quality of color quantization (conversion of images to the maximum 256
 225 |    * colors allowed by the GIF specification). Lower values (minimum = 1)
 226 |    * produce better colors, but slow processing significantly. 10 is the
 227 |    * default, and produces good color mapping at reasonable speeds. Values
 228 |    * greater than 20 do not yield significant improvements in speed.
 229 |    * 
 230 |    * @param quality
 231 |    *          int greater than 0.
 232 |    * @return
 233 |    */
 234 |   public void setQuality(int quality) {
 235 |     if (quality < 1)
 236 |       quality = 1;
 237 |     sample = quality;
 238 |   }
 239 | 
 240 |   /**
 241 |    * Sets the GIF frame size. The default size is the size of the first frame
 242 |    * added if this method is not invoked.
 243 |    * 
 244 |    * @param w
 245 |    *          int frame width.
 246 |    * @param h
 247 |    *          int frame width.
 248 |    */
 249 |   public void setSize(int w, int h) {
 250 |     if (started && !firstFrame)
 251 |       return;
 252 |     width = w;
 253 |     height = h;
 254 |     if (width < 1)
 255 |       width = 320;
 256 |     if (height < 1)
 257 |       height = 240;
 258 |     sizeSet = true;
 259 |   }
 260 | 
 261 |   /**
 262 |    * Initiates GIF file creation on the given stream. The stream is not closed
 263 |    * automatically.
 264 |    * 
 265 |    * @param os
 266 |    *          OutputStream on which GIF images are written.
 267 |    * @return false if initial write failed.
 268 |    */
 269 |   public boolean start(OutputStream os) {
 270 |     if (os == null)
 271 |       return false;
 272 |     boolean ok = true;
 273 |     closeStream = false;
 274 |     out = os;
 275 |     try {
 276 |       writeString("GIF89a"); // header
 277 |     } catch (IOException e) {
 278 |       ok = false;
 279 |     }
 280 |     return started = ok;
 281 |   }
 282 | 
 283 |   /**
 284 |    * Initiates writing of a GIF file with the specified name.
 285 |    * 
 286 |    * @param file
 287 |    *          String containing output file name.
 288 |    * @return false if open or initial write failed.
 289 |    */
 290 |   public boolean start(String file) {
 291 |     boolean ok = true;
 292 |     try {
 293 |       out = new BufferedOutputStream(new FileOutputStream(file));
 294 |       ok = start(out);
 295 |       closeStream = true;
 296 |     } catch (IOException e) {
 297 |       ok = false;
 298 |     }
 299 |     return started = ok;
 300 |   }
 301 | 
 302 |   /**
 303 |    * Analyzes image colors and creates color map.
 304 |    */
 305 |   protected void analyzePixels() {
 306 |     int len = pixels.length;
 307 |     int nPix = len / 3;
 308 |     indexedPixels = new byte[nPix];
 309 |     NeuQuant nq = new NeuQuant(pixels, len, sample);
 310 |     // initialize quantizer
 311 |     colorTab = nq.process(); // create reduced palette
 312 |     // convert map from BGR to RGB
 313 |     for (int i = 0; i < colorTab.length; i += 3) {
 314 |       byte temp = colorTab[i];
 315 |       colorTab[i] = colorTab[i + 2];
 316 |       colorTab[i + 2] = temp;
 317 |       usedEntry[i / 3] = false;
 318 |     }
 319 |     // map image pixels to new palette
 320 |     int k = 0;
 321 |     for (int i = 0; i < nPix; i++) {
 322 |       int index = nq.map(pixels[k++] & 0xff, pixels[k++] & 0xff, pixels[k++] & 0xff);
 323 |       usedEntry[index] = true;
 324 |       indexedPixels[i] = (byte) index;
 325 |     }
 326 |     pixels = null;
 327 |     colorDepth = 8;
 328 |     palSize = 7;
 329 |     // get closest match to transparent color if specified
 330 |     if (transparent != null) {
 331 |       transIndex = findClosest(transparent);
 332 |     }
 333 |   }
 334 | 
 335 |   /**
 336 |    * Returns index of palette color closest to c
 337 |    * 
 338 |    */
 339 |   protected int findClosest(Color c) {
 340 |     if (colorTab == null)
 341 |       return -1;
 342 |     int r = c.getRed();
 343 |     int g = c.getGreen();
 344 |     int b = c.getBlue();
 345 |     int minpos = 0;
 346 |     int dmin = 256 * 256 * 256;
 347 |     int len = colorTab.length;
 348 |     for (int i = 0; i < len;) {
 349 |       int dr = r - (colorTab[i++] & 0xff);
 350 |       int dg = g - (colorTab[i++] & 0xff);
 351 |       int db = b - (colorTab[i] & 0xff);
 352 |       int d = dr * dr + dg * dg + db * db;
 353 |       int index = i / 3;
 354 |       if (usedEntry[index] && (d < dmin)) {
 355 |         dmin = d;
 356 |         minpos = index;
 357 |       }
 358 |       i++;
 359 |     }
 360 |     return minpos;
 361 |   }
 362 | 
 363 |   /**
 364 |    * Extracts image pixels into byte array "pixels"
 365 |    */
 366 |   protected void getImagePixels() {
 367 |     int w = image.getWidth();
 368 |     int h = image.getHeight();
 369 |     int type = image.getType();
 370 |     if ((w != width) || (h != height) || (type != BufferedImage.TYPE_3BYTE_BGR)) {
 371 |       // create new image with right size/format
 372 |       BufferedImage temp = new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR);
 373 |       Graphics2D g = temp.createGraphics();
 374 |       g.drawImage(image, 0, 0, null);
 375 |       image = temp;
 376 |     }
 377 |     pixels = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
 378 |   }
 379 | 
 380 |   /**
 381 |    * Writes Graphic Control Extension
 382 |    */
 383 |   protected void writeGraphicCtrlExt() throws IOException {
 384 |     out.write(0x21); // extension introducer
 385 |     out.write(0xf9); // GCE label
 386 |     out.write(4); // data block size
 387 |     int transp, disp;
 388 |     if (transparent == null) {
 389 |       transp = 0;
 390 |       disp = 0; // dispose = no action
 391 |     } else {
 392 |       transp = 1;
 393 |       disp = 2; // force clear if using transparent color
 394 |     }
 395 |     if (dispose >= 0) {
 396 |       disp = dispose & 7; // user override
 397 |     }
 398 |     disp <<= 2;
 399 | 
 400 |     // packed fields
 401 |     out.write(0 | // 1:3 reserved
 402 |         disp | // 4:6 disposal
 403 |         0 | // 7 user input - 0 = none
 404 |         transp); // 8 transparency flag
 405 | 
 406 |     writeShort(delay); // delay x 1/100 sec
 407 |     out.write(transIndex); // transparent color index
 408 |     out.write(0); // block terminator
 409 |   }
 410 | 
 411 |   /**
 412 |    * Writes Image Descriptor
 413 |    */
 414 |   protected void writeImageDesc() throws IOException {
 415 |     out.write(0x2c); // image separator
 416 |     writeShort(0); // image position x,y = 0,0
 417 |     writeShort(0);
 418 |     writeShort(width); // image size
 419 |     writeShort(height);
 420 |     // packed fields
 421 |     if (firstFrame) {
 422 |       // no LCT - GCT is used for first (or only) frame
 423 |       out.write(0);
 424 |     } else {
 425 |       // specify normal LCT
 426 |       out.write(0x80 | // 1 local color table 1=yes
 427 |           0 | // 2 interlace - 0=no
 428 |           0 | // 3 sorted - 0=no
 429 |           0 | // 4-5 reserved
 430 |           palSize); // 6-8 size of color table
 431 |     }
 432 |   }
 433 | 
 434 |   /**
 435 |    * Writes Logical Screen Descriptor
 436 |    */
 437 |   protected void writeLSD() throws IOException {
 438 |     // logical screen size
 439 |     writeShort(width);
 440 |     writeShort(height);
 441 |     // packed fields
 442 |     out.write((0x80 | // 1 : global color table flag = 1 (gct used)
 443 |         0x70 | // 2-4 : color resolution = 7
 444 |         0x00 | // 5 : gct sort flag = 0
 445 |         palSize)); // 6-8 : gct size
 446 | 
 447 |     out.write(0); // background color index
 448 |     out.write(0); // pixel aspect ratio - assume 1:1
 449 |   }
 450 | 
 451 |   /**
 452 |    * Writes Netscape application extension to define repeat count.
 453 |    */
 454 |   protected void writeNetscapeExt() throws IOException {
 455 |     out.write(0x21); // extension introducer
 456 |     out.write(0xff); // app extension label
 457 |     out.write(11); // block size
 458 |     writeString("NETSCAPE" + "2.0"); // app id + auth code
 459 |     out.write(3); // sub-block size
 460 |     out.write(1); // loop sub-block id
 461 |     writeShort(repeat); // loop count (extra iterations, 0=repeat forever)
 462 |     out.write(0); // block terminator
 463 |   }
 464 | 
 465 |   /**
 466 |    * Writes color table
 467 |    */
 468 |   protected void writePalette() throws IOException {
 469 |     out.write(colorTab, 0, colorTab.length);
 470 |     int n = (3 * 256) - colorTab.length;
 471 |     for (int i = 0; i < n; i++) {
 472 |       out.write(0);
 473 |     }
 474 |   }
 475 | 
 476 |   /**
 477 |    * Encodes and writes pixel data
 478 |    */
 479 |   protected void writePixels() throws IOException {
 480 |     LZWEncoder encoder = new LZWEncoder(width, height, indexedPixels, colorDepth);
 481 |     encoder.encode(out);
 482 |   }
 483 | 
 484 |   /**
 485 |    * Write 16-bit value to output stream, LSB first
 486 |    */
 487 |   protected void writeShort(int value) throws IOException {
 488 |     out.write(value & 0xff);
 489 |     out.write((value >> 8) & 0xff);
 490 |   }
 491 | 
 492 |   /**
 493 |    * Writes string to output stream
 494 |    */
 495 |   protected void writeString(String s) throws IOException {
 496 |     for (int i = 0; i < s.length(); i++) {
 497 |       out.write((byte) s.charAt(i));
 498 |     }
 499 |   }
 500 | }
 501 | 
 502 | /*
 503 |  * NeuQuant Neural-Net Quantization Algorithm
 504 |  * ------------------------------------------
 505 |  * 
 506 |  * Copyright (c) 1994 Anthony Dekker
 507 |  * 
 508 |  * NEUQUANT Neural-Net quantization algorithm by Anthony Dekker, 1994. See
 509 |  * "Kohonen neural networks for optimal colour quantization" in "Network:
 510 |  * Computation in Neural Systems" Vol. 5 (1994) pp 351-367. for a discussion of
 511 |  * the algorithm.
 512 |  * 
 513 |  * Any party obtaining a copy of these files from the author, directly or
 514 |  * indirectly, is granted, free of charge, a full and unrestricted irrevocable,
 515 |  * world-wide, paid up, royalty-free, nonexclusive right and license to deal in
 516 |  * this software and documentation files (the "Software"), including without
 517 |  * limitation the rights to use, copy, modify, merge, publish, distribute,
 518 |  * sublicense, and/or sell copies of the Software, and to permit persons who
 519 |  * receive copies from any such party to do so, with the only requirement being
 520 |  * that this copyright notice remain intact.
 521 |  */
 522 | 
 523 | // Ported to Java 12/00 K Weiner
 524 | class NeuQuant {
 525 | 
 526 |   protected static final int netsize = 256; /* number of colours used */
 527 | 
 528 |   /* four primes near 500 - assume no image has a length so large */
 529 |   /* that it is divisible by all four primes */
 530 |   protected static final int prime1 = 499;
 531 | 
 532 |   protected static final int prime2 = 491;
 533 | 
 534 |   protected static final int prime3 = 487;
 535 | 
 536 |   protected static final int prime4 = 503;
 537 | 
 538 |   protected static final int minpicturebytes = (3 * prime4);
 539 | 
 540 |   /* minimum size for input image */
 541 | 
 542 |   /*
 543 |    * Program Skeleton ---------------- [select samplefac in range 1..30] [read
 544 |    * image from input file] pic = (unsigned char*) malloc(3*width*height);
 545 |    * initnet(pic,3*width*height,samplefac); learn(); unbiasnet(); [write output
 546 |    * image header, using writecolourmap(f)] inxbuild(); write output image using
 547 |    * inxsearch(b,g,r)
 548 |    */
 549 | 
 550 |   /*
 551 |    * Network Definitions -------------------
 552 |    */
 553 | 
 554 |   protected static final int maxnetpos = (netsize - 1);
 555 | 
 556 |   protected static final int netbiasshift = 4; /* bias for colour values */
 557 | 
 558 |   protected static final int ncycles = 100; /* no. of learning cycles */
 559 | 
 560 |   /* defs for freq and bias */
 561 |   protected static final int intbiasshift = 16; /* bias for fractions */
 562 | 
 563 |   protected static final int intbias = (((int) 1) << intbiasshift);
 564 | 
 565 |   protected static final int gammashift = 10; /* gamma = 1024 */
 566 | 
 567 |   protected static final int gamma = (((int) 1) << gammashift);
 568 | 
 569 |   protected static final int betashift = 10;
 570 | 
 571 |   protected static final int beta = (intbias >> betashift); /* beta = 1/1024 */
 572 | 
 573 |   protected static final int betagamma = (intbias << (gammashift - betashift));
 574 | 
 575 |   /* defs for decreasing radius factor */
 576 |   protected static final int initrad = (netsize >> 3); /*
 577 |                                                          * for 256 cols, radius
 578 |                                                          * starts
 579 |                                                          */
 580 | 
 581 |   protected static final int radiusbiasshift = 6; /* at 32.0 biased by 6 bits */
 582 | 
 583 |   protected static final int radiusbias = (((int) 1) << radiusbiasshift);
 584 | 
 585 |   protected static final int initradius = (initrad * radiusbias); /*
 586 |                                                                    * and
 587 |                                                                    * decreases
 588 |                                                                    * by a
 589 |                                                                    */
 590 | 
 591 |   protected static final int radiusdec = 30; /* factor of 1/30 each cycle */
 592 | 
 593 |   /* defs for decreasing alpha factor */
 594 |   protected static final int alphabiasshift = 10; /* alpha starts at 1.0 */
 595 | 
 596 |   protected static final int initalpha = (((int) 1) << alphabiasshift);
 597 | 
 598 |   protected int alphadec; /* biased by 10 bits */
 599 | 
 600 |   /* radbias and alpharadbias used for radpower calculation */
 601 |   protected static final int radbiasshift = 8;
 602 | 
 603 |   protected static final int radbias = (((int) 1) << radbiasshift);
 604 | 
 605 |   protected static final int alpharadbshift = (alphabiasshift + radbiasshift);
 606 | 
 607 |   protected static final int alpharadbias = (((int) 1) << alpharadbshift);
 608 | 
 609 |   /*
 610 |    * Types and Global Variables --------------------------
 611 |    */
 612 | 
 613 |   protected byte[] thepicture; /* the input image itself */
 614 | 
 615 |   protected int lengthcount; /* lengthcount = H*W*3 */
 616 | 
 617 |   protected int samplefac; /* sampling factor 1..30 */
 618 | 
 619 |   // typedef int pixel[4]; /* BGRc */
 620 |   protected int[][] network; /* the network itself - [netsize][4] */
 621 | 
 622 |   protected int[] netindex = new int[256];
 623 | 
 624 |   /* for network lookup - really 256 */
 625 | 
 626 |   protected int[] bias = new int[netsize];
 627 | 
 628 |   /* bias and freq arrays for learning */
 629 |   protected int[] freq = new int[netsize];
 630 | 
 631 |   protected int[] radpower = new int[initrad];
 632 | 
 633 |   /* radpower for precomputation */
 634 | 
 635 |   /*
 636 |    * Initialise network in range (0,0,0) to (255,255,255) and set parameters
 637 |    * -----------------------------------------------------------------------
 638 |    */
 639 |   public NeuQuant(byte[] thepic, int len, int sample) {
 640 | 
 641 |     int i;
 642 |     int[] p;
 643 | 
 644 |     thepicture = thepic;
 645 |     lengthcount = len;
 646 |     samplefac = sample;
 647 | 
 648 |     network = new int[netsize][];
 649 |     for (i = 0; i < netsize; i++) {
 650 |       network[i] = new int[4];
 651 |       p = network[i];
 652 |       p[0] = p[1] = p[2] = (i << (netbiasshift + 8)) / netsize;
 653 |       freq[i] = intbias / netsize; /* 1/netsize */
 654 |       bias[i] = 0;
 655 |     }
 656 |   }
 657 | 
 658 |   public byte[] colorMap() {
 659 |     byte[] map = new byte[3 * netsize];
 660 |     int[] index = new int[netsize];
 661 |     for (int i = 0; i < netsize; i++)
 662 |       index[network[i][3]] = i;
 663 |     int k = 0;
 664 |     for (int i = 0; i < netsize; i++) {
 665 |       int j = index[i];
 666 |       map[k++] = (byte) (network[j][0]);
 667 |       map[k++] = (byte) (network[j][1]);
 668 |       map[k++] = (byte) (network[j][2]);
 669 |     }
 670 |     return map;
 671 |   }
 672 | 
 673 |   /*
 674 |    * Insertion sort of network and building of netindex[0..255] (to do after
 675 |    * unbias)
 676 |    * -------------------------------------------------------------------------------
 677 |    */
 678 |   public void inxbuild() {
 679 | 
 680 |     int i, j, smallpos, smallval;
 681 |     int[] p;
 682 |     int[] q;
 683 |     int previouscol, startpos;
 684 | 
 685 |     previouscol = 0;
 686 |     startpos = 0;
 687 |     for (i = 0; i < netsize; i++) {
 688 |       p = network[i];
 689 |       smallpos = i;
 690 |       smallval = p[1]; /* index on g */
 691 |       /* find smallest in i..netsize-1 */
 692 |       for (j = i + 1; j < netsize; j++) {
 693 |         q = network[j];
 694 |         if (q[1] < smallval) { /* index on g */
 695 |           smallpos = j;
 696 |           smallval = q[1]; /* index on g */
 697 |         }
 698 |       }
 699 |       q = network[smallpos];
 700 |       /* swap p (i) and q (smallpos) entries */
 701 |       if (i != smallpos) {
 702 |         j = q[0];
 703 |         q[0] = p[0];
 704 |         p[0] = j;
 705 |         j = q[1];
 706 |         q[1] = p[1];
 707 |         p[1] = j;
 708 |         j = q[2];
 709 |         q[2] = p[2];
 710 |         p[2] = j;
 711 |         j = q[3];
 712 |         q[3] = p[3];
 713 |         p[3] = j;
 714 |       }
 715 |       /* smallval entry is now in position i */
 716 |       if (smallval != previouscol) {
 717 |         netindex[previouscol] = (startpos + i) >> 1;
 718 |         for (j = previouscol + 1; j < smallval; j++)
 719 |           netindex[j] = i;
 720 |         previouscol = smallval;
 721 |         startpos = i;
 722 |       }
 723 |     }
 724 |     netindex[previouscol] = (startpos + maxnetpos) >> 1;
 725 |     for (j = previouscol + 1; j < 256; j++)
 726 |       netindex[j] = maxnetpos; /* really 256 */
 727 |   }
 728 | 
 729 |   /*
 730 |    * Main Learning Loop ------------------
 731 |    */
 732 |   public void learn() {
 733 | 
 734 |     int i, j, b, g, r;
 735 |     int radius, rad, alpha, step, delta, samplepixels;
 736 |     byte[] p;
 737 |     int pix, lim;
 738 | 
 739 |     if (lengthcount < minpicturebytes)
 740 |       samplefac = 1;
 741 |     alphadec = 30 + ((samplefac - 1) / 3);
 742 |     p = thepicture;
 743 |     pix = 0;
 744 |     lim = lengthcount;
 745 |     samplepixels = lengthcount / (3 * samplefac);
 746 |     delta = samplepixels / ncycles;
 747 |     alpha = initalpha;
 748 |     radius = initradius;
 749 | 
 750 |     rad = radius >> radiusbiasshift;
 751 |     if (rad <= 1)
 752 |       rad = 0;
 753 |     for (i = 0; i < rad; i++)
 754 |       radpower[i] = alpha * (((rad * rad - i * i) * radbias) / (rad * rad));
 755 | 
 756 |     // fprintf(stderr,"beginning 1D learning: initial radius=%d\n", rad);
 757 | 
 758 |     if (lengthcount < minpicturebytes)
 759 |       step = 3;
 760 |     else if ((lengthcount % prime1) != 0)
 761 |       step = 3 * prime1;
 762 |     else {
 763 |       if ((lengthcount % prime2) != 0)
 764 |         step = 3 * prime2;
 765 |       else {
 766 |         if ((lengthcount % prime3) != 0)
 767 |           step = 3 * prime3;
 768 |         else
 769 |           step = 3 * prime4;
 770 |       }
 771 |     }
 772 | 
 773 |     i = 0;
 774 |     while (i < samplepixels) {
 775 |       b = (p[pix + 0] & 0xff) << netbiasshift;
 776 |       g = (p[pix + 1] & 0xff) << netbiasshift;
 777 |       r = (p[pix + 2] & 0xff) << netbiasshift;
 778 |       j = contest(b, g, r);
 779 | 
 780 |       altersingle(alpha, j, b, g, r);
 781 |       if (rad != 0)
 782 |         alterneigh(rad, j, b, g, r); /* alter neighbours */
 783 | 
 784 |       pix += step;
 785 |       if (pix >= lim)
 786 |         pix -= lengthcount;
 787 | 
 788 |       i++;
 789 |       if (delta == 0)
 790 |         delta = 1;
 791 |       if (i % delta == 0) {
 792 |         alpha -= alpha / alphadec;
 793 |         radius -= radius / radiusdec;
 794 |         rad = radius >> radiusbiasshift;
 795 |         if (rad <= 1)
 796 |           rad = 0;
 797 |         for (j = 0; j < rad; j++)
 798 |           radpower[j] = alpha * (((rad * rad - j * j) * radbias) / (rad * rad));
 799 |       }
 800 |     }
 801 |     // fprintf(stderr,"finished 1D learning: final alpha=%f
 802 |     // !\n",((float)alpha)/initalpha);
 803 |   }
 804 | 
 805 |   /*
 806 |    * Search for BGR values 0..255 (after net is unbiased) and return colour
 807 |    * index
 808 |    * ----------------------------------------------------------------------------
 809 |    */
 810 |   public int map(int b, int g, int r) {
 811 | 
 812 |     int i, j, dist, a, bestd;
 813 |     int[] p;
 814 |     int best;
 815 | 
 816 |     bestd = 1000; /* biggest possible dist is 256*3 */
 817 |     best = -1;
 818 |     i = netindex[g]; /* index on g */
 819 |     j = i - 1; /* start at netindex[g] and work outwards */
 820 | 
 821 |     while ((i < netsize) || (j >= 0)) {
 822 |       if (i < netsize) {
 823 |         p = network[i];
 824 |         dist = p[1] - g; /* inx key */
 825 |         if (dist >= bestd)
 826 |           i = netsize; /* stop iter */
 827 |         else {
 828 |           i++;
 829 |           if (dist < 0)
 830 |             dist = -dist;
 831 |           a = p[0] - b;
 832 |           if (a < 0)
 833 |             a = -a;
 834 |           dist += a;
 835 |           if (dist < bestd) {
 836 |             a = p[2] - r;
 837 |             if (a < 0)
 838 |               a = -a;
 839 |             dist += a;
 840 |             if (dist < bestd) {
 841 |               bestd = dist;
 842 |               best = p[3];
 843 |             }
 844 |           }
 845 |         }
 846 |       }
 847 |       if (j >= 0) {
 848 |         p = network[j];
 849 |         dist = g - p[1]; /* inx key - reverse dif */
 850 |         if (dist >= bestd)
 851 |           j = -1; /* stop iter */
 852 |         else {
 853 |           j--;
 854 |           if (dist < 0)
 855 |             dist = -dist;
 856 |           a = p[0] - b;
 857 |           if (a < 0)
 858 |             a = -a;
 859 |           dist += a;
 860 |           if (dist < bestd) {
 861 |             a = p[2] - r;
 862 |             if (a < 0)
 863 |               a = -a;
 864 |             dist += a;
 865 |             if (dist < bestd) {
 866 |               bestd = dist;
 867 |               best = p[3];
 868 |             }
 869 |           }
 870 |         }
 871 |       }
 872 |     }
 873 |     return (best);
 874 |   }
 875 | 
 876 |   public byte[] process() {
 877 |     learn();
 878 |     unbiasnet();
 879 |     inxbuild();
 880 |     return colorMap();
 881 |   }
 882 | 
 883 |   /*
 884 |    * Unbias network to give byte values 0..255 and record position i to prepare
 885 |    * for sort
 886 |    * -----------------------------------------------------------------------------------
 887 |    */
 888 |   public void unbiasnet() {
 889 | 
 890 |     int i, j;
 891 | 
 892 |     for (i = 0; i < netsize; i++) {
 893 |       network[i][0] >>= netbiasshift;
 894 |       network[i][1] >>= netbiasshift;
 895 |       network[i][2] >>= netbiasshift;
 896 |       network[i][3] = i; /* record colour no */
 897 |     }
 898 |   }
 899 | 
 900 |   /*
 901 |    * Move adjacent neurons by precomputed alpha*(1-((i-j)^2/[r]^2)) in
 902 |    * radpower[|i-j|]
 903 |    * ---------------------------------------------------------------------------------
 904 |    */
 905 |   protected void alterneigh(int rad, int i, int b, int g, int r) {
 906 | 
 907 |     int j, k, lo, hi, a, m;
 908 |     int[] p;
 909 | 
 910 |     lo = i - rad;
 911 |     if (lo < -1)
 912 |       lo = -1;
 913 |     hi = i + rad;
 914 |     if (hi > netsize)
 915 |       hi = netsize;
 916 | 
 917 |     j = i + 1;
 918 |     k = i - 1;
 919 |     m = 1;
 920 |     while ((j < hi) || (k > lo)) {
 921 |       a = radpower[m++];
 922 |       if (j < hi) {
 923 |         p = network[j++];
 924 |         try {
 925 |           p[0] -= (a * (p[0] - b)) / alpharadbias;
 926 |           p[1] -= (a * (p[1] - g)) / alpharadbias;
 927 |           p[2] -= (a * (p[2] - r)) / alpharadbias;
 928 |         } catch (Exception e) {
 929 |         } // prevents 1.3 miscompilation
 930 |       }
 931 |       if (k > lo) {
 932 |         p = network[k--];
 933 |         try {
 934 |           p[0] -= (a * (p[0] - b)) / alpharadbias;
 935 |           p[1] -= (a * (p[1] - g)) / alpharadbias;
 936 |           p[2] -= (a * (p[2] - r)) / alpharadbias;
 937 |         } catch (Exception e) {
 938 |         }
 939 |       }
 940 |     }
 941 |   }
 942 | 
 943 |   /*
 944 |    * Move neuron i towards biased (b,g,r) by factor alpha
 945 |    * ----------------------------------------------------
 946 |    */
 947 |   protected void altersingle(int alpha, int i, int b, int g, int r) {
 948 | 
 949 |     /* alter hit neuron */
 950 |     int[] n = network[i];
 951 |     n[0] -= (alpha * (n[0] - b)) / initalpha;
 952 |     n[1] -= (alpha * (n[1] - g)) / initalpha;
 953 |     n[2] -= (alpha * (n[2] - r)) / initalpha;
 954 |   }
 955 | 
 956 |   /*
 957 |    * Search for biased BGR values ----------------------------
 958 |    */
 959 |   protected int contest(int b, int g, int r) {
 960 | 
 961 |     /* finds closest neuron (min dist) and updates freq */
 962 |     /* finds best neuron (min dist-bias) and returns position */
 963 |     /* for frequently chosen neurons, freq[i] is high and bias[i] is negative */
 964 |     /* bias[i] = gamma*((1/netsize)-freq[i]) */
 965 | 
 966 |     int i, dist, a, biasdist, betafreq;
 967 |     int bestpos, bestbiaspos, bestd, bestbiasd;
 968 |     int[] n;
 969 | 
 970 |     bestd = ~(((int) 1) << 31);
 971 |     bestbiasd = bestd;
 972 |     bestpos = -1;
 973 |     bestbiaspos = bestpos;
 974 | 
 975 |     for (i = 0; i < netsize; i++) {
 976 |       n = network[i];
 977 |       dist = n[0] - b;
 978 |       if (dist < 0)
 979 |         dist = -dist;
 980 |       a = n[1] - g;
 981 |       if (a < 0)
 982 |         a = -a;
 983 |       dist += a;
 984 |       a = n[2] - r;
 985 |       if (a < 0)
 986 |         a = -a;
 987 |       dist += a;
 988 |       if (dist < bestd) {
 989 |         bestd = dist;
 990 |         bestpos = i;
 991 |       }
 992 |       biasdist = dist - ((bias[i]) >> (intbiasshift - netbiasshift));
 993 |       if (biasdist < bestbiasd) {
 994 |         bestbiasd = biasdist;
 995 |         bestbiaspos = i;
 996 |       }
 997 |       betafreq = (freq[i] >> betashift);
 998 |       freq[i] -= betafreq;
 999 |       bias[i] += (betafreq << gammashift);
1000 |     }
1001 |     freq[bestpos] += beta;
1002 |     bias[bestpos] -= betagamma;
1003 |     return (bestbiaspos);
1004 |   }
1005 | }
1006 | 
1007 | // ==============================================================================
1008 | // Adapted from Jef Poskanzer's Java port by way of J. M. G. Elliott.
1009 | // K Weiner 12/00
1010 | 
1011 | class LZWEncoder {
1012 | 
1013 |   private static final int EOF = -1;
1014 | 
1015 |   private int imgW, imgH;
1016 | 
1017 |   private byte[] pixAry;
1018 | 
1019 |   private int initCodeSize;
1020 | 
1021 |   private int remaining;
1022 | 
1023 |   private int curPixel;
1024 | 
1025 |   // GIFCOMPR.C - GIF Image compression routines
1026 |   //
1027 |   // Lempel-Ziv compression based on 'compress'. GIF modifications by
1028 |   // David Rowley (mgardi@watdcsu.waterloo.edu)
1029 | 
1030 |   // General DEFINEs
1031 | 
1032 |   static final int BITS = 12;
1033 | 
1034 |   static final int HSIZE = 5003; // 80% occupancy
1035 | 
1036 |   // GIF Image compression - modified 'compress'
1037 |   //
1038 |   // Based on: compress.c - File compression ala IEEE Computer, June 1984.
1039 |   //
1040 |   // By Authors: Spencer W. Thomas (decvax!harpo!utah-cs!utah-gr!thomas)
1041 |   // Jim McKie (decvax!mcvax!jim)
1042 |   // Steve Davies (decvax!vax135!petsd!peora!srd)
1043 |   // Ken Turkowski (decvax!decwrl!turtlevax!ken)
1044 |   // James A. Woods (decvax!ihnp4!ames!jaw)
1045 |   // Joe Orost (decvax!vax135!petsd!joe)
1046 | 
1047 |   int n_bits; // number of bits/code
1048 | 
1049 |   int maxbits = BITS; // user settable max # bits/code
1050 | 
1051 |   int maxcode; // maximum code, given n_bits
1052 | 
1053 |   int maxmaxcode = 1 << BITS; // should NEVER generate this code
1054 | 
1055 |   int[] htab = new int[HSIZE];
1056 | 
1057 |   int[] codetab = new int[HSIZE];
1058 | 
1059 |   int hsize = HSIZE; // for dynamic table sizing
1060 | 
1061 |   int free_ent = 0; // first unused entry
1062 | 
1063 |   // block compression parameters -- after all codes are used up,
1064 |   // and compression rate changes, start over.
1065 |   boolean clear_flg = false;
1066 | 
1067 |   // Algorithm: use open addressing double hashing (no chaining) on the
1068 |   // prefix code / next character combination. We do a variant of Knuth's
1069 |   // algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
1070 |   // secondary probe. Here, the modular division first probe is gives way
1071 |   // to a faster exclusive-or manipulation. Also do block compression with
1072 |   // an adaptive reset, whereby the code table is cleared when the compression
1073 |   // ratio decreases, but after the table fills. The variable-length output
1074 |   // codes are re-sized at this point, and a special CLEAR code is generated
1075 |   // for the decompressor. Late addition: construct the table according to
1076 |   // file size for noticeable speed improvement on small files. Please direct
1077 |   // questions about this implementation to ames!jaw.
1078 | 
1079 |   int g_init_bits;
1080 | 
1081 |   int ClearCode;
1082 | 
1083 |   int EOFCode;
1084 | 
1085 |   // output
1086 |   //
1087 |   // Output the given code.
1088 |   // Inputs:
1089 |   // code: A n_bits-bit integer. If == -1, then EOF. This assumes
1090 |   // that n_bits =< wordsize - 1.
1091 |   // Outputs:
1092 |   // Outputs code to the file.
1093 |   // Assumptions:
1094 |   // Chars are 8 bits long.
1095 |   // Algorithm:
1096 |   // Maintain a BITS character long buffer (so that 8 codes will
1097 |   // fit in it exactly). Use the VAX insv instruction to insert each
1098 |   // code in turn. When the buffer fills up empty it and start over.
1099 | 
1100 |   int cur_accum = 0;
1101 | 
1102 |   int cur_bits = 0;
1103 | 
1104 |   int masks[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF,
1105 |       0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
1106 | 
1107 |   // Number of characters so far in this 'packet'
1108 |   int a_count;
1109 | 
1110 |   // Define the storage for the packet accumulator
1111 |   byte[] accum = new byte[256];
1112 | 
1113 |   // ----------------------------------------------------------------------------
1114 |   LZWEncoder(int width, int height, byte[] pixels, int color_depth) {
1115 |     imgW = width;
1116 |     imgH = height;
1117 |     pixAry = pixels;
1118 |     initCodeSize = Math.max(2, color_depth);
1119 |   }
1120 | 
1121 |   // Add a character to the end of the current packet, and if it is 254
1122 |   // characters, flush the packet to disk.
1123 |   void char_out(byte c, OutputStream outs) throws IOException {
1124 |     accum[a_count++] = c;
1125 |     if (a_count >= 254)
1126 |       flush_char(outs);
1127 |   }
1128 | 
1129 |   // Clear out the hash table
1130 | 
1131 |   // table clear for block compress
1132 |   void cl_block(OutputStream outs) throws IOException {
1133 |     cl_hash(hsize);
1134 |     free_ent = ClearCode + 2;
1135 |     clear_flg = true;
1136 | 
1137 |     output(ClearCode, outs);
1138 |   }
1139 | 
1140 |   // reset code table
1141 |   void cl_hash(int hsize) {
1142 |     for (int i = 0; i < hsize; ++i)
1143 |       htab[i] = -1;
1144 |   }
1145 | 
1146 |   void compress(int init_bits, OutputStream outs) throws IOException {
1147 |     int fcode;
1148 |     int i /* = 0 */;
1149 |     int c;
1150 |     int ent;
1151 |     int disp;
1152 |     int hsize_reg;
1153 |     int hshift;
1154 | 
1155 |     // Set up the globals: g_init_bits - initial number of bits
1156 |     g_init_bits = init_bits;
1157 | 
1158 |     // Set up the necessary values
1159 |     clear_flg = false;
1160 |     n_bits = g_init_bits;
1161 |     maxcode = MAXCODE(n_bits);
1162 | 
1163 |     ClearCode = 1 << (init_bits - 1);
1164 |     EOFCode = ClearCode + 1;
1165 |     free_ent = ClearCode + 2;
1166 | 
1167 |     a_count = 0; // clear packet
1168 | 
1169 |     ent = nextPixel();
1170 | 
1171 |     hshift = 0;
1172 |     for (fcode = hsize; fcode < 65536; fcode *= 2)
1173 |       ++hshift;
1174 |     hshift = 8 - hshift; // set hash code range bound
1175 | 
1176 |     hsize_reg = hsize;
1177 |     cl_hash(hsize_reg); // clear hash table
1178 | 
1179 |     output(ClearCode, outs);
1180 | 
1181 |     outer_loop: while ((c = nextPixel()) != EOF) {
1182 |       fcode = (c << maxbits) + ent;
1183 |       i = (c << hshift) ^ ent; // xor hashing
1184 | 
1185 |       if (htab[i] == fcode) {
1186 |         ent = codetab[i];
1187 |         continue;
1188 |       } else if (htab[i] >= 0) // non-empty slot
1189 |       {
1190 |         disp = hsize_reg - i; // secondary hash (after G. Knott)
1191 |         if (i == 0)
1192 |           disp = 1;
1193 |         do {
1194 |           if ((i -= disp) < 0)
1195 |             i += hsize_reg;
1196 | 
1197 |           if (htab[i] == fcode) {
1198 |             ent = codetab[i];
1199 |             continue outer_loop;
1200 |           }
1201 |         } while (htab[i] >= 0);
1202 |       }
1203 |       output(ent, outs);
1204 |       ent = c;
1205 |       if (free_ent < maxmaxcode) {
1206 |         codetab[i] = free_ent++; // code -> hashtable
1207 |         htab[i] = fcode;
1208 |       } else
1209 |         cl_block(outs);
1210 |     }
1211 |     // Put out the final code.
1212 |     output(ent, outs);
1213 |     output(EOFCode, outs);
1214 |   }
1215 | 
1216 |   // ----------------------------------------------------------------------------
1217 |   void encode(OutputStream os) throws IOException {
1218 |     os.write(initCodeSize); // write "initial code size" byte
1219 | 
1220 |     remaining = imgW * imgH; // reset navigation variables
1221 |     curPixel = 0;
1222 | 
1223 |     compress(initCodeSize + 1, os); // compress and write the pixel data
1224 | 
1225 |     os.write(0); // write block terminator
1226 |   }
1227 | 
1228 |   // Flush the packet to disk, and reset the accumulator
1229 |   void flush_char(OutputStream outs) throws IOException {
1230 |     if (a_count > 0) {
1231 |       outs.write(a_count);
1232 |       outs.write(accum, 0, a_count);
1233 |       a_count = 0;
1234 |     }
1235 |   }
1236 | 
1237 |   final int MAXCODE(int n_bits) {
1238 |     return (1 << n_bits) - 1;
1239 |   }
1240 | 
1241 |   // ----------------------------------------------------------------------------
1242 |   // Return the next pixel from the image
1243 |   // ----------------------------------------------------------------------------
1244 |   private int nextPixel() {
1245 |     if (remaining == 0)
1246 |       return EOF;
1247 | 
1248 |     --remaining;
1249 | 
1250 |     byte pix = pixAry[curPixel++];
1251 | 
1252 |     return pix & 0xff;
1253 |   }
1254 | 
1255 |   void output(int code, OutputStream outs) throws IOException {
1256 |     cur_accum &= masks[cur_bits];
1257 | 
1258 |     if (cur_bits > 0)
1259 |       cur_accum |= (code << cur_bits);
1260 |     else
1261 |       cur_accum = code;
1262 | 
1263 |     cur_bits += n_bits;
1264 | 
1265 |     while (cur_bits >= 8) {
1266 |       char_out((byte) (cur_accum & 0xff), outs);
1267 |       cur_accum >>= 8;
1268 |       cur_bits -= 8;
1269 |     }
1270 | 
1271 |     // If the next entry is going to be too big for the code size,
1272 |     // then increase it, if possible.
1273 |     if (free_ent > maxcode || clear_flg) {
1274 |       if (clear_flg) {
1275 |         maxcode = MAXCODE(n_bits = g_init_bits);
1276 |         clear_flg = false;
1277 |       } else {
1278 |         ++n_bits;
1279 |         if (n_bits == maxbits)
1280 |           maxcode = maxmaxcode;
1281 |         else
1282 |           maxcode = MAXCODE(n_bits);
1283 |       }
1284 |     }
1285 | 
1286 |     if (code == EOFCode) {
1287 |       // At EOF, write the rest of the buffer.
1288 |       while (cur_bits > 0) {
1289 |         char_out((byte) (cur_accum & 0xff), outs);
1290 |         cur_accum >>= 8;
1291 |         cur_bits -= 8;
1292 |       }
1293 | 
1294 |       flush_char(outs);
1295 |     }
1296 |   }
1297 | }


--------------------------------------------------------------------------------