<blockquote>
<p><strong>DISCLAIMER:</strong> This was a five-person group project, and it certainly would not have gotten done without the respectable efforts of most of my teammates. However, I would like to take credit for a majority of the work aside from the starred bullet points below. :-)</p>
</blockquote>
<p>This operating system runs in QEMU and targets the RISC-V architecture. It is mostly written in C (some assembly required) and boasts the following features:</p>
<ul>
<li>page-grained physical memory allocation</li>
<li>RISC-V Sv39 MMU (39-bit virtual addresses, 56-bit physical addresses)<ul>
<li>separate address spaces for the kernel heap and each process&#39; stack and heap</li>
</ul>
</li>
<li>PCIe memory-mapped I/O</li>
<li>drivers for the following VirtIO devices:<ul>
<li>random number generator*</li>
<li>keyboard input*</li>
<li>tablet input</li>
<li>block devices (to mount <code>.dsk</code> files to)</li>
<li>GPU (for drawing rectangles, circles, and strings from a bitmap font)</li>
</ul>
</li>
<li>Minix 3 file system*</li>
<li>processes and round-robin scheduling*</li>
<li>runnable ELF files loadable from the file system</li>
<li>support for user space applications, including system calls<ul>
<li>currently runs a primitive version of MS Paint that allows for drawing with a fixed set of colors and sizes, saving a selection of the screen as a PPM image, and pasting an existing PPM image from the file system</li>
</ul>
</li>
</ul>
<p>Now, this is hardly cutting-edge technology, but I think it is still an accomplishment to be proud of, and I&#39;ve gained a high level of respect for those who work on actual operating systems. To take a step back and look at the final result (albeit imperfect) knowing just how much learning, planning, and debugging went into it is a really good feeling&mdash;a satisfying payoff.</p>
<p>The <code>README.md</code> file included in the <a href="https://github.com/s4mpl/cs562">repository</a> is a journal of the project&#39;s progress and highlights most of the major bugs and challenges we overcame. I don&#39;t have access to the original commit history, so unfortunately that is gone forever.</p>
<hr>

<p>Here&#39;s a small showcase of the user space application in action:</p>
<figure class='text-center'>
  <img width='500px' height='500px' src='/images/operating-system/operating-system-1.gif' class='mx-auto'/>
  <figcaption>Input device events captured for drawing.</figcaption>
</figure>

<figure class='text-center'>
  <img width='500px' height='500px' src='/images/operating-system/operating-system-2.png' class='mx-auto'/>
  <figcaption>Various colors and brush size combinations selectable via the keyboard.</figcaption>
</figure>

<figure class='text-center'>
  <img width='500px' height='500px' src='/images/operating-system/operating-system-3.gif' class='mx-auto'/>
  <figcaption>Loading a PPM image from disk&mdash;Dr. Marz has never looked better!</figcaption>
</figure>

<figure class='text-center'>
  <img width='500px' height='500px' src='/images/operating-system/operating-system-4.png' class='mx-auto'/>
  <figcaption>Copying a selection, saving it to disk as a PPM image, and pasting it.</figcaption>
</figure>

<p>Admittedly not a very professional theme (so I&#39;ve avoided marketing it such), but we were having a lot of fun with it and did a play on words with the game <em>Among Us</em> and arrived at...</p>
<figure class='text-center'>
  <img width='500px' height='500px' src='/images/operating-system/operating-system-5.gif' class='mx-auto'/>
  <figcaption>Splash screen upon booting the OS (plus a use of the random number generator).</figcaption>
</figure>


A course-long project for COSC 562 – Operating Systems: Design & Impementation

Custom Operating System

<p>This project was done in collaboration with Drew Friend, a good friend and fellow robotics enthusiast. Our work is in the form of a <a href="/Bio-Inspired_Comp_Final_Poster.pdf">poster</a> and <a href="/COSC_527____Final_Project.pdf">paper</a>.</p>
<p>Our code to train models and the interactive simulation of the trained models used for our demo can be found <a href="https://github.com/s4mpl/Bio-Inspired_Final_Project">here</a>.</p>


Final project for COSC 527 – Biologically-Inspired Computation: a novel application of genetic algorithms to robotics

Evolving Neural Networks with NEAT to Control an X-Drive Robot

<p>You can find our slides <a href="/COSC-581_Collision-Detection-Algorithms.pdf">here</a>.</p>
<p>Our semi-optimized Python implementation of 2D AABB trees (a data structure often found in this field) can be found within the slides or <a href="https://github.com/rjbray915/CS581-Final">here</a>.</p>


Final project for the core graduate course COSC 581 – Algorithms: a two-person 45-minute presentation on a topic of our choice

Collision Detection Algorithms

<h3 id="intro">Intro</h3>
<p>This class, a new upper-division special topics elective titled &quot;Interactive Technologies in Human-Computer Interaction,&quot; is geared towards computer science students with no prior experience with hands-on projects involving microcontrollers or any real background in electronics. It aims to teach the skills necessary to design and prototype small electronic devices using simple parts that would allow the user to interact with a program through physical actions, and it has an interesting approach to documentation for our larger-scale projects. Instead of just writing reports, we get to do it through a more casual and fitting medium: a blog! I am writing with reproducibility and refinement in mind&mdash;I lay out all the steps I took and make note of things I wish I had done differently or could have known to do for a better outcome, so if I ever did this again in the future (or if you wanted to follow along 🙂), the post would hopefully be beneficial. Failure is one of the best teachers.</p>
<blockquote>
<p>&#10077; Fail early and fail often.&#10078;</p>
</blockquote>
<h3 id="projects">Projects</h3>
<p>This blog has a post for each of the &quot;mini group projects&quot; (working in pairs) and the final project:</p>

<ul>
<li><a href='./cosc594-blog/miniproject1' target='_self'>mgProject 1: &quot;Interactive 8x8 Gaming Machine&quot;</a></li>
<li><a href='./cosc594-blog/miniproject2' target='_self'>mgProject 2: &quot;Interactive Input/Output with Low-Tech&quot;</a></li>
<li><a href='./cosc594-blog/miniproject3' target='_self'>mgProject 3: &quot;IMU, Motors, and such&quot;</a></li>
<li><a href='./cosc594-blog/finalproject' target='_self'>Final Project: GuardianLock</a></li>
</ul>

My blog for a class specializing in creating small gadgets that allow humans to interact with computers in novel ways

COSC 594 – Interactive Tech in HCI

Helpful resource for setting up your coding environment and understanding the lab writeup

COSC 302 Lab 1: Fuel

<p>See the &quot;external link&quot; icon on this post&#39;s entry or <a href="/COSC_312____Homework_8b__Group_9.pdf">click here</a>.</p>


A class project in Turing machine design for COSC 312 – Algorithm Analysis and Automata

C++ Increment Syntax Parsing Turing Machine

<h3 id="intro">Intro</h3>
<p>This is going to be a shorter post since this website speaks for itself, but I do want to share some general information and resources for those wanting to create something similar. I also want to highlight some details that I learned were customizable while building my site.</p>
<h3 id="tools--technologies-used">Tools / technologies used</h3>
<p>I started this project with <a href="https://www.youtube.com/watch?v=pY0vWYLDDco">a helpful tutorial from Ben Awad</a>. The site utilizes Next.js&#39;s <a href="https://nextjs.org/docs/basic-features/pages#static-generation-recommended">static site generation (SSG)</a> feature, which allows it to fetch posts from a content management system (CMS) and dynamically render HTML elements for each from just a markdown (<code>.md</code>) file. It&#39;s confusing, and I can&#39;t really explain how anything works, but Next.js basically makes things a lot easier and cleaner. I used to try creating websites with pure HTML and CSS, and I hated every bit of it, but I actually genuinely enjoyed putting this site together with Next.js once I got the ball rolling.</p>
<p>I&#39;m also not a fan of CSS, but I did find <a href="https://tailwindcss.com/">Tailwind CSS</a> to be a very nice framework that made styling things feel <em>much</em> better. Tailwind is an example of &quot;atomic&quot; or &quot;functional&quot; CSS, a different approach to styling which favors applying many single-purpose classes with names based on visual function. There are a few of these out there, but I chose Tailwind because it has great <a href="https://tailwindcss.com/docs/typography-plugin">out-of-the-box markdown styling</a> and still allowed for as much customization as I wanted using the configuration file and by overwriting the generated default styles in <code>output.css</code> from <code>input.css</code>:</p>
<pre><code class="language-sh">npx tailwindcss -i ./styles/input.css -o ./styles/output.css --watch
</code></pre>
<p>See <a href="https://tailwindcss.com/docs/installation">the installation guide</a> for more information about how it works. Tailwind also provides great documentation with the ability to &quot;quick search&quot; for a page regarding the certain thing you&#39;re trying to do.</p>
<blockquote>
<p>To learn more about atomic CSS in general, I highly recommend reading <a href="https://antfu.me/posts/reimagine-atomic-css">this post by Anthony Fu</a>&mdash;it&#39;s where I learned about it in the first place!</p>
</blockquote>
<p>For my markdown parsing and codeblock syntax highlighting, I used Node.js&#39;s <code>npm</code> (Node package manager) to install <a href="https://www.npmjs.com/package/gray-matter">gray-matter</a> for markdown-to-object conversion (splits content and metadata), <a href="https://marked.js.org/">marked.js</a> for markdown-to-HTML parsing, and <a href="https://highlightjs.org/">highlight.js</a> for syntax highlighting. The first two are also included in Ben Awad&#39;s tutorial linked above.</p>
<p>Finally, another great thing about Next.js is that the creator, Vercel, makes it easy to deploy. They&#39;ll host your site for free, and you can buy a custom domain name (from somewhere like <a href="https://www.namecheap.com/">namecheap.com</a>) and assign it. There&#39;s also Git repository integration, so your pushed changes can be deployed automatically.</p>
<h3 id="a-few-details">A few details</h3>
<p>I love finding little details that can be customized. </p>
<hr>

<p>When browsing through the Tailwind docs, I saw that I could edit the color of text selection:</p>
<h6 id="inputcss">input.css</h6>
<pre><code class="language-css">@layer base {
  html {
    @apply selection:bg-[#334155] selection:text-slate-100;
    @apply bg-[#ededed];
  }
  html.dark {
    @apply selection:bg-slate-100 selection:text-slate-800;
    @apply bg-htmldark;
  }
  h6 {
    @apply text-xs ml-2 mt-1.5;
  }
}
</code></pre>
<p>This is also where I fixed the background color of the page (when zoomed too far out on mobile) and added a custom styling for <code>h6</code>, which I use specifically for the little file name above my codeblocks sometimes.</p>
<p>While messing with selection color, I noticed that you could select the text in my navbar, which felt wrong when doing &quot;select all&quot; (<code>ctrl+A</code>), which I cared about for some reason. To combat this, I just had to add <code>select-none</code> to my navbar component.</p>
<hr>

<p>I also put in a lot of effort to support a fully styled light mode, despite its inferiority to dark mode, because I liked the &quot;Projects / Posts&quot; colors. I had to do this weird double-invert thing in order to flip the colors of the background image and text properly:</p>
<h6 id="background-containerjs">background-container.js</h6>
<pre><code class="language-js">export default function BackgroundContainer({children}) {
  return (
    &lt;div className=&#39;invert dark:invert-0 bg-cover bg-center h-screen&#39;
    style={{backgroundImage: &quot;linear-gradient(rgb(18 18 18 / 0.8), rgb(18 18 18 / 1)), url(&#39;/images/background.png&#39;)&quot;}}&gt;
      &lt;div className=&#39;invert dark:invert-0&#39;&gt;
        {children}
      &lt;/div&gt;
    &lt;/div&gt;
  );
}
</code></pre>
<p>Also in that code snippet, my background color does this nice fade to dark / light as the page goes down since the image won&#39;t span the length of the page&mdash;similar to how Steam profile backgrounds behave.</p>
<hr>

<h3 id="conclusion">Conclusion</h3>
<p>Thanks for reading through! I hope you find this collection of information helpful if you start a Next.js SSG project of your own.</p>


This website! Created primarily using Next.js and Tailwind CSS

Personal Portfolio

<h3 id="intro">Intro</h3>
<p>This is a server plugin for the game <a href="https://en.wikipedia.org/wiki/Minecraft">Minecraft</a> (Java edition) that allows players to interact with a global item market through chat commands. Every item has a buy and sell price, every player has a balance, and there&#39;s a leaderboard showing all current player balances&mdash;though these features are pretty standard. The twist is that every item has a configurable exponential curve that its price follows based on how many have been bought and sold, creating an economy based on supply and demand. Players can also view the market&#39;s highest and lowest percent changes in price to see if there&#39;s an opportunity to make money or to avoid buying certain artificially scarce items.</p>
<p>I developed it with a friend specifically for our group&#39;s survival multiplayer server, and it worked well and was a pretty fun enhancement to the Vanilla Minecraft experience. You can check out the <a href="https://github.com/tareqalyousef/DynamicShop">repository</a> for implementation details and even add it to your own server if you want to try it out.</p>
<p>In this post, I&#39;ll showcase some commands and talk about interesting strategies we discovered to earn money, which was ultimately based on our somewhat arbitrary default pricing and a <em>bit</em> of oversight, but all items settled to their true value eventually, so I&#39;d say it worked as intended.</p>
<figure class='text-center'>
  <img src='/images/dynamic-shop/dynamic-shop-5.png' class='mx-auto'/>
  <figcaption>My search for netherite had adverse effects on netherrack and quartz holders.</figcaption>
</figure>

<h3 id="what-is-a-plugin">What is a plugin?</h3>
<p>Servers hosted with <a href="https://www.spigotmc.org/">Spigot</a> contain modified server files that allow for the use of plugins, additions to the game without changing the game itself (unlike a mod). A plugin is typically a new system that stores information that can interact with the players or world and maybe adds some commands to allow players to interact back. Similar to browser extensions.</p>
<h3 id="dynamicshop-at-work">DynamicShop at work</h3>
<p>This is the list of commands:</p>
<pre><code class="language-yml">buy:
  description: Buy an item from the global shop.
  usage: /buy &lt;item&gt; &lt;amount&gt;
sell:
  description: Sell an item to the global shop.
  usage: /sell &lt;item&gt; [&lt;amount&gt; | all]
balance:
  aliases: [bal]
  description: Check your balance.
  usage: /balance, /bal
leaderboard:
  aliases: [baltop]
  description: Check the highest balances on the server.
  usage: /leaderboard, /baltop
price:
  description: Check the price of an item.
  usage: /price &lt;item&gt;
highest:
  description: Check highest item percentage changes.
  usage: /highest
lowest:
  description: Check lowest item percentage changes.
  usage: /lowest
quote:
  description: Quote a price for buying or selling a quantity of an item.
  usage: /quote [buy | sell] &lt;item&gt; [&lt;amount&gt; | all]
</code></pre>
<p>Below I have provided the commands typed to produce the output in the screenshot.</p>
<hr>

<pre><code class="language-c">/price diamond
/sell diamond 200
/sell diamond 2000 (Note: this will still sell as many as you have, up to this amount)
</code></pre>
<figure class='text-center'>
  <img src='/images/dynamic-shop/dynamic-shop-1.png' class='mx-auto'/>
  <figcaption>A quick limit test.</figcaption>
</figure>

<hr>

<pre><code class="language-c">/quote sell stone all
/sell stone all
[refill inventory]
/sell stone all
[refill inventory]
/sell stone all
/price stone
/lowest
</code></pre>
<figure class='text-center'>
  <img src='/images/dynamic-shop/dynamic-shop-2.png' class='mx-auto'/>
  <figcaption></figcaption>
</figure>

<hr>

<pre><code class="language-c">/buy arrow 64
/price totem_of_undying
/quote sell totem_of_undying all
/sell saddle all
/baltop
</code></pre>
<figure class='text-center'>
  <img src='/images/dynamic-shop/dynamic-shop-4.png' class='mx-auto'/>
  <figcaption>Always on top.</figcaption>
</figure>

<hr>

<h3 id="finding-breakthroughs-in-the-market">Finding breakthroughs in the market</h3>
<p>Now what&#39;s a free market without exploitation? When using this plugin for ourselves, we discovered both some flaws in the pricing system and more creative opportunities to get rich quick.</p>
<figure class='text-center'>
  <img src='/images/dynamic-shop/dynamic-shop-3.png' class='mx-auto'/>
  <figcaption>Something is going on in the rotten flesh market...</figcaption>
</figure>

<hr>

<p>In the early game, the most expensive items that players could immediately acquire were certain colored dyes. You could find a field of flowers that crafted light gray dye and start going ham, leaving your bank account with many <em>tens</em> of dollars by the end of it. This meant you could at least buy some good food to get through the first nights or start saving up.</p>
<p>Sheep farming was also a very easy way to earn money since you can obtain wool without killing the sheep, so it&#39;s easier to grow the population. Starting at $30 each (by our default prices), the first player to break into the wool market would be able to make quite a bit. Also, since each wool color had its own separate price, you could buy dyes to combine with the wool to basically bring the value back up to $30 and sell that. Since there was now a demand for the dyes, their prices were brought back up, and the players still out picking flowers would earn a lot more too by helping the wool sellers keep the price down, leveling the playing field in a way. Isn&#39;t that cool?</p>
<hr>

<p>Now this was the biggest flaw: prices of items directly proportional to each other in crafting were completely separate. The best example is the new copper ore, since it was really easy to get a lot of and was good for nothing but selling.</p>
<h6 id="defaultsyml">defaults.yml</h6>
<pre><code class="language-yml">RAW_COPPER: 4.0
RAW_COPPER_BLOCK: 36.0
COPPER_ORE: 24.0
DEEPSLATE_COPPER_ORE: 24.0
COPPER_INGOT: 16.0
COPPER_BLOCK: 144.0
</code></pre>
<p>You can get around 2–5 units of raw copper per copper ore mined. Smelting raw copper yields more expensive copper ingots. A copper block is 9 ingots, so it&#39;s 9 times the price. Makes sense.</p>
<p>However, since each of these items were independently priced, once the prices began changing from the defaults, there was an imbalance. Copper ingots were being sold so much that their value was low enough for players to make money by <em>buying</em> 9 copper ingots, crafting a copper block for free, and selling the <em>block</em> back at 85% market value. You can see where this is going.</p>
<p>In the screenshot above, note that we had mined <strong>so much copper</strong> that we were too lazy to even exploit the system anymore and just started selling the raw copper.</p>
<hr>

<p>Finally, a more legitimate trick that I actually discovered. Cleric villagers buy 32 rotten flesh for 1 emerald, which is only good for trading with other villagers, but that&#39;s not a bad deal. This plugin introduced a new market for emeralds&mdash;one where they were worth $256. Since rotten flesh was only valued at $2 by default, this was the perfect arbitrage opportunity. You could buy a ton of rotten flesh and trade it to the cleric each day for up to 4 times the value until it stopped turning a profit. Genius. As a side effect, killing zombies was worth something.</p>
<hr>

<h3 id="conclusion">Conclusion</h3>
<p>My friend and I might build upon the plugin in the future and address these issues, but they were fun to abuse, and I almost feel like it contributed in a good way to the overall experience, perhaps remaining as a reward to those who find them.</p>


A Spigot-based Minecraft server plugin that features a global item shop with fluctuating prices based on supply and demand

DynamicShop

A top-down 2D shooter written in C++ using SFML and a physics engine made from scratch

Survival Simulator

<h3 id="intro">Intro</h3>
<p>My very first personal project. How exciting!</p>
<p>This was a Discord bot created in late 2017 using <a href="https://discord4j.com/">Discord4J</a> 2.9.3, a Java wrapper for the official Discord Bot API. At the time, I was in 10th grade&mdash;halfway through my &quot;AP Computer Science A&quot; course with nothing but basic Java skills and a dream.</p>
<blockquote>
<p><strong>Note:</strong> Sadly, this bot is no longer publicly available since I host it locally and have to constantly be running the program to keep it online.</p>
</blockquote>
<h3 id="what-is-discord">What is Discord?</h3>
<p><a href="https://en.wikipedia.org/wiki/Discord">Discord</a> is a social platform released in 2015 that was becoming increasingly popular due to its unique take on organized communication and variety of free services. You can create a collection of chat and voice channels called a server and invite other users to form an online community. Interestingly, servers would be able to make use of user-developed bot accounts to grant the ability to execute custom commands or automate aspects of a server such as authentication and moderation.</p>
<h3 id="how-do-bots-work">How do bots work?</h3>
<p>Once you request and receive an API token, you can start a bot and invite it to your server. Bots have some form of event handlers that listen to anything it can pick up in direct messages or server channels it has access to&mdash;messages, reactions, even users joining and speaking in a voice channel&mdash;and allow them to respond however you can program it. Every user, server, and channel has a unique id, so you can add custom functionality to very specific events as well.</p>
<h3 id="its-alive">It&#39;s alive!</h3>
<p>Discord4J provided a helpful tutorial on setting up basic functionality in <a href="https://www.jetbrains.com/idea/">IntelliJ</a>. It was surprisingly easy to set up, and, with as little experience as I had, I was able to get an instance of a Discord client configured and running.</p>
<figure class='text-center'>
  <img src='/images/discord-bot/discord-bot-6.png' class='mx-auto'/>
  <figcaption>A celebration of a Discord bot rite of passage.</figcaption>
</figure>

<blockquote>
<p><strong>Note:</strong> There are a lot of longer code blocks in this post simply because I&#39;m not making the whole project public, so feel free to skip these. They are intended to provide a bit of insight about a bot&#39;s inner-workings and show generally what the syntax is like, but it&#39;s quite outdated now and honestly boring to read through unless you&#39;re genuinely interested.</p>
</blockquote>
<p>This is the heart of the bot:</p>
<h6 id="botutilsjava">BotUtils.java</h6>
<pre><code class="language-java">// Handles the creation and getting of a IDiscordClient object for a token
static IDiscordClient getBuiltDiscordClient(String token) {
    // The ClientBuilder object is where you will attach your params for configuring the instance of your bot.
    // Such as withToken, setDaemon etc
    return new ClientBuilder()
            .withToken(token)
            .withRecommendedShardCount()
            .build();

}

// Helper functions to make certain aspects of the bot easier to use.
static void sendMessage(IChannel channel, String message) {
    RequestBuffer.request(() -&gt; {
        try {
            channel.sendMessage(message);
        } catch(DiscordException e) {
            System.out.println(&quot;Message (&quot; + message + &quot;) from &quot; + channel.getName() + &quot; in &quot; + channel.getGuild().getName() + &quot; could not be sent with error: &quot;);
            e.printStackTrace();
        }
    });
}
</code></pre>
<h6 id="mainrunnerjava">MainRunner.java</h6>
<pre><code class="language-java">public static void main(String[] args) {
    args = new String[1];
    args[0] = &quot;MY API TOKEN&quot;;

    IDiscordClient cli = BotUtils.getBuiltDiscordClient(args[0]);

    cli.getDispatcher().registerListener(new CommandHandler());
    cli.login();
}
</code></pre>
<p>Then it was on to commands containing actual arguments.</p>
<p>Below you can see the program structure and get a general idea for how commands are executed. An <code>@EventSubscriber</code> receives a type of event and handles it from there. In this case, receiving messages, the message&#39;s contents are split into an argument array for parsing. I had also implemented the option to change the command prefix, including the ability for it to contain whitespace. This file is essentially the brains of the bot and contains most of the logic for responses. Since this is pretty old, the code quality may be questionable, so please don&#39;t judge me:</p>
<h6 id="commandhandlerjava">CommandHandler.java</h6>
<pre><code class="language-java">@EventSubscriber
public void onMessageReceived(MessageReceivedEvent event) {
    try {
        ...
        // Given a message &quot;/test arg1 arg2&quot;, argArray will contain [&quot;/test&quot;, &quot;arg1&quot;, &quot;arg2&quot;]
        String argArray[];
        if(!BotUtils.BOT_PREFIX.contains(&quot; &quot;))
            argArray = event.getMessage().getContent().split(&quot; &quot;);
        // Given a message &quot;okay google test arg1 arg2&quot;, argArray will contain [&quot;okay google test&quot;, &quot;arg1&quot;, &quot;arg2&quot;] (if &quot;okay google &quot; is the prefix)
        else if(event.getMessage().getContent().startsWith(BotUtils.BOT_PREFIX)) {
            argArray = event.getMessage().getContent().substring(BotUtils.BOT_PREFIX.length()).split(&quot; &quot;);
            String[] newArray = Arrays.copyOf(argArray, argArray.length);
            newArray[0] = BotUtils.BOT_PREFIX + argArray[0];
            for(int i = 1; i &lt; newArray.length; i++) {
                newArray[i] = argArray[i];
            }

            argArray = newArray;
        } else {
            argArray = event.getMessage().getContent().split(&quot; &quot;);
        }

        // Check if the first arg (the command) starts with the prefix defined in the utils class
        if(!argArray[0].startsWith(BotUtils.BOT_PREFIX))
            return;
        
        // Extract the &quot;command&quot; part of the first arg out by just ditching the prefix
        String commandStr = argArray[0].substring(BotUtils.BOT_PREFIX.length());

        // Load the rest of the args in the array into a List for safer access
        List&lt;String&gt; argsList = new ArrayList&lt;&gt;(Arrays.asList(argArray));
        argsList.remove(0); // Remove the command

        // Begin the switch to handle the string to command mappings. It&#39;s likely wise to pass the whole event or
        // some part (IChannel) to the command handling it
        switch(commandStr) {
            case &quot;test&quot;:
                test(event, argsList);
                break;
            case &quot;ping&quot;:
                ping(event);
                break;
        }
        ...
    }
    ...
}

@EventSubscriber
public void onVoiceInputReceived(UserSpeakingEvent event) { ... }

private void test(MessageReceivedEvent event, List&lt;String&gt; args) {
    BotUtils.sendMessage(event.getChannel(), &quot;args: &quot; + args);
}

private void ping(MessageReceivedEvent event) {
    BotUtils.sendMessage(event.getChannel(), &quot;Pong!&quot;);
}
</code></pre>
<figure class='text-center'>
  <img src='/images/discord-bot/discord-bot-1.png' class='mx-auto'/>
  <figcaption>No problem.</figcaption>
</figure>

<h3 id="some-more-implementation-details-and-examples">Some more implementation details and examples</h3>
<p>Before I added more commands, I was interested in allowing each server to set its <em>own</em> command prefix since it was still being done globally. To do this, I had to create a hashmap of server ids to serializable <code>ServerSettings</code> objects and stored a serialized copy of the map as a local file. Every time I restarted the bot, it needed to load the saved settings back in, and before each message event was handled, the server-specific settings were pulled from the map:</p>
<h6 id="mainrunnerjava-1">MainRunner.java</h6>
<pre><code class="language-java">public static void main(String[] args) {
    // Loading settings from serversettings.txt
    try {
        HashMap&lt;String, ServerSettings&gt; object = (HashMap&lt;String, ServerSettings&gt;) Serialization.deSerialization(
                &quot;C:\\Users\\brandan\\path\\to\\serversettings.txt&quot;);
        CommandHandler.settings = object;
        System.out.println(CommandHandler.getSettings());
    } catch(IOException | ClassNotFoundException e) {
        e.printStackTrace();
    }

    args = new String[1];
    ...
}
</code></pre>
<h6 id="commandhandlerjava-1">CommandHandler.java</h6>
<pre><code class="language-java">@EventSubscriber
public void onMessageReceived(MessageReceivedEvent event) {
    try {
        // If the server isn&#39;t in serversettings.txt, add it with default settings
        if(!settings.containsKey(event.getGuild().getStringID()))
            settings.put(event.getGuild().getStringID(), new ServerSettings(&quot;/&quot;));

        // Loads in server settings for the event
        BotUtils.BOT_PREFIX = settings.get(event.getGuild().getStringID()).getPrefix();
        ...
        // Serialization to update settings right after a command
        try {
            Serialization.serialization(&quot;C:\\Users\\brandan\\path\\to\\serversettings.txt&quot;, settings);
            // System.out.println(&quot;!\n&quot; + CommandHandler.getSettings() + &quot;!&quot;);
        } catch(IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    ...
}

...

private void setPrefix(MessageReceivedEvent event, List&lt;String&gt; args) {
    if(event.getAuthor().equals(event.getGuild().getOwner()) || event.getAuthor().getStringID().equalsIgnoreCase(&quot;217070114254618626&quot;)) {
        if(args.size() == 1) {
            settings.replace(event.getGuild().getStringID(), new ServerSettings(args.get(0)));
            BotUtils.sendMessage(event.getChannel(), &quot;Prefix has been set to \&quot;&quot; + args.get(0) + &quot;\&quot;&quot;);
        }
        else if(args.size() &gt; 1) {
            String newPrefix = &quot;&quot;;
            for(String arg : args) {
                newPrefix += arg + &quot; &quot;;
            }

            settings.replace(event.getGuild().getStringID(), new ServerSettings(newPrefix));
            BotUtils.sendMessage(event.getChannel(), &quot;Prefix has been set to \&quot;&quot; + newPrefix + &quot;\&quot;&quot;);
        }
        else {
            BotUtils.sendMessage(event.getChannel(), &quot;Please enter a prefix.&quot;);
        }
    }
    else {
        BotUtils.sendMessage(event.getChannel(), &quot;You don&#39;t have the power to do that.&quot;);
    }
}
</code></pre>
<p>You get the idea. Here&#39;s the full list commands that were made public:</p>
<ul>
<li><code>/help</code> - PMs you this list of commands</li>
<li><code>/ping</code> - Pong!</li>
<li><code>/8ball</code> - Answers yes or no questions with a randomly selected response</li>
<li><code>/coinflip</code> - Flips a coin</li>
<li><code>/prefix</code> - Changes the prefix (usable by server owners only; use with any character, word(s), or phrase(s) (it can be almost anything))</li>
<li><code>resetprefix</code> - Resets the prefix (useable by server owners only)</li>
<li><code>/colorrgb</code> - Gives the color and its hexadecimal value given the R G B values (use with three integers between 0 and 255 inclusive * separated by a space)</li>
<li><code>/colorhex</code> - Gives the color and its R B G values given the hexadecimal value (use with a hexadecimal value with a length of 6)</li>
<li><code>/google</code> - Returns the first 1000 characters of a Google search (use with anything you would usually type into Google)</li>
</ul>
<figure class='text-center'>
  <img src='/images/discord-bot/discord-bot-2.png' class='mx-auto'/>
  <figcaption></figcaption>
</figure>

<p>Additionally, I had a &quot;fun&quot; system, where the bot had a chance to automatically respond to messages containing certain keywords without being explicitly commanded to, giving it a sort of personality. I used the server settings file to keep track of each servers&#39; preferences, and this could be configured using these commands:</p>
<ul>
<li><code>/disablefun</code> - Sets the bot to not autorespond regardless of fun level (useable by server owners only)</li>
<li><code>/enablefun</code> - Allows the bot to autorespond (useable by server owners only)</li>
<li><code>/fun</code> - Sets the fun level (usable by server owners only; use with a number between 0 and 1 inclusive, which will be the chance of the bot autoresponding)</li>
<li><code>/funlevel</code> - Returns the fun level</li>
</ul>
<p>Here&#39;s an example:</p>
<h6 id="commandhandlerjava-2">CommandHandler.java</h6>
<pre><code class="language-java">@EventSubscriber
public void onMessageReceived(MessageReceivedEvent event) {
    try {
        ...
        // Autoresponse
        if(fun) {
            double random = (int) (Math.random() * (1 / funLevel)) + 1;

            if(random == 1 / funLevel) {
                ...
                // @s4mple Bot check
                int atCheck = 0;
                for(String name : argArray) {
                    if(name.contains(&quot;&lt;@396595556492771339&gt;&quot;)) {
                        atCheck++;
                        break;
                    }
                }
                if(atCheck &gt; 0)
                    goAway(event);
                ...
            }
        }
        ...
    }
    ...
}

...

private void goAway(MessageReceivedEvent event) {
    int random = (int)(Math.random() * 6) + 1;
    if(random == 1)
        BotUtils.sendMessage(event.getChannel(), &quot;leave me alone&quot;);
    if(random == 2)
        BotUtils.sendMessage(event.getChannel(), &quot;go away&quot;);
    if(random == 3)
        BotUtils.sendMessage(event.getChannel(), &quot;what do you want?&quot;);
    if(random == 4)
        BotUtils.sendMessage(event.getChannel(), &quot;how do you like it when i do it to you, huh? &quot; + event.getAuthor().mention());
    if(random == 5)
        BotUtils.sendMessage(event.getChannel(), &quot;that wasn&#39;t very nice&quot;);
    if(random == 6)
        BotUtils.sendMessage(event.getChannel(), &quot;stop it&quot;);
}
</code></pre>
<figure class='text-center'>
  <img src='/images/discord-bot/discord-bot-7.png' class='mx-auto'/>
  <figcaption></figcaption>
</figure>

<p>I was particularly proud of these two commands where I was messing around with embed colors:</p>
<h6 id="commandhandlerjava-3">CommandHandler.java</h6>
<pre><code class="language-java">private void colorRGB(MessageReceivedEvent event, List&lt;String&gt; args) {
    try {
        int r = Integer.parseInt(args.get(0));
        int g = Integer.parseInt(args.get(1));
        int b = Integer.parseInt(args.get(2));

        EmbedBuilder builder = new EmbedBuilder();
        builder.withColor(r, g, b);
        builder.withAuthorName(&quot;&lt;- This is color rgb(&quot; + r + &quot;, &quot; + g + &quot;, &quot; + b + &quot;)&quot;);
        builder.withDescription(&quot;Hexadecimal: #&quot; + (Integer.toHexString(r) + Integer.toHexString(g) + Integer.toHexString(b)).toUpperCase());
        event.getChannel().sendMessage(builder.build());
    } catch (Exception e) {
        BotUtils.sendMessage(event.getChannel(), &quot;Please enter three integers between 0 and 255 inclusive (R, G, B).&quot;);
        throw e;
    }
}

private void colorHex(MessageReceivedEvent event, List&lt;String&gt; args) {
    try {
        int r, g, b;
        EmbedBuilder builder = new EmbedBuilder();
        String hex = args.get(0);
        if(hex.startsWith(&quot;#&quot;)) {
            r = Integer.parseInt(hex.substring(1, 3), 16);
            g = Integer.parseInt(hex.substring(3, 5), 16);
            b = Integer.parseInt(hex.substring(5), 16);
            builder.withAuthorName(&quot;&lt;- This is color &quot; + hex.toUpperCase());
        } else {
            r = Integer.parseInt(hex.substring(0, 2), 16);
            g = Integer.parseInt(hex.substring(2, 4), 16);
            b = Integer.parseInt(hex.substring(4), 16);
            builder.withAuthorName(&quot;&lt;- This is color #&quot; + hex.toUpperCase());
        }
        builder.withColor(r, g, b);
        builder.withDescription(&quot;R G B: (&quot; + r + &quot;, &quot; + g + &quot;, &quot; + b + &quot;)&quot;);
        event.getChannel().sendMessage(builder.build());
    } catch (Exception e) {
        BotUtils.sendMessage(event.getChannel(), &quot;Please enter a hexadecimal number with a length of 6.&quot;);
        throw e;
    }
}
</code></pre>
<figure class='text-center'>
  <img src='/images/discord-bot/discord-bot-3.png' class='mx-auto'/>
  <figcaption></figcaption>
</figure>

<p>One private experimental feature was the ability to join a voice channel and play a local sound file (either on command or automatically whenever a specific user was talking using a <a href="https://javadoc.io/static/com.discord4j/Discord4J/2.10.1/sx/blah/discord/handle/impl/events/guild/voice/user/UserSpeakingEvent.html"><code>UserSpeakingEvent</code>*</a>) as a prank:</p>
<h6 id="commandhandlerjava-4">CommandHandler.java</h6>
<pre><code class="language-java">@EventSubscriber
public void onVoiceInputReceived(UserSpeakingEvent event) {
    String targetID = &quot;217070114254618626&quot;;
    if(event.getUser().getStringID().equals(&quot;396595556492771339&quot;)) { // bot&#39;s ID
        botIsSpeaking = event.isSpeaking();
    }
    if(event.getUser().getStringID().equals(targetID))  { // target&#39;s ID
        targetIsSpeaking = event.isSpeaking();
    }
    if(!botIsSpeaking &amp;&amp; targetIsSpeaking) {
        PlaySound.play(event, &quot;sound_effect&quot;);
        // System.out.println(&quot;speak now&quot;);
    }
}
</code></pre>
<h6 id="playsoundjava">PlaySound.java</h6>
<pre><code class="language-java">public static void play(UserSpeakingEvent event, String searchStr) {
    IVoiceChannel userVoiceChannel = event.getUser().getVoiceStateForGuild(event.getGuild()).getChannel();
    if(userVoiceChannel == null)
        return;
    userVoiceChannel.join();

    AudioPlayer ap = AudioPlayer.getAudioPlayerForGuild(event.getGuild());

    // Find a song given the search term
    File[] songs = new File(&quot;C:\\Users\\brandan\\path\\to\\music&quot;)
            .listFiles(file -&gt; file.getName().contains(searchStr));

    if(songs == null || songs.length == 0)
        return;

    ap.clear();
    try {
        ap.queue(songs[0]);
    } catch(IOException | UnsupportedAudioFileException e) {
        e.printStackTrace();
    }
}
</code></pre>
<h3 id="conclusion">Conclusion</h3>
<p>Now what I had was <em>nothing</em> compared to the amazing things people had done at the time. There were already bots that could play music from multiple platforms, scrape web pages and display the information, and even simulate full-on interactive games in chat, and Discord and its dedicated bot developer community continue to invent new ways to use them. However, in the end, it was still a lot of fun to create and was a great learning experience to reflect upon.</p>
<figure class='text-center'>
  <img src='/images/discord-bot/discord-bot-5.png' class='mx-auto'/>
  <figcaption>s4mple Bot's final message.</figcaption>
</figure>

My own Discord bot with a bunch of random commands and features

Brandan