Tukukkk

This is a programming challenge I set for myself a while back to create an AI that starts with no knowledge of anything whatsoever, and learns as you talk to it. (It can learn stuff like your name, how to say hello, goodbye, etc.)

I tried to use the least amount of hard-coded responses as possible. I'm happy that it works, but I feel like the code behind it is very clumsy and... just not very good. The program is called Genesis. Tell me what you think!

Genesis.java

package genesis;



import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintStream;

import java.io.PrintWriter;

import java.util.regex.Matcher;

import java.util.regex.Pattern;



public final class Genesis {



public static final String name = "Genesis";

public static final String version = "1.0";



public static void main(String args) {

    try {

        new Genesis();

    } catch(IOException e) {

        printError(new PrintWriter(System.err), e);

    }

}



private final FileManager fm;

protected String last = null;



public Genesis() throws IOException {

    log("Initializing " + toString() + "...");

    log("Generating files...");

    fm = new FileManager(this);

    log(toString() + " started on " + System.getProperty("os.name"));

    start();

    stop();

}



public void stop() {

    stop(0);

}



public void stop(int error) {

    if(error == 0)

        log(toString() + " shut down successfully!");

    else

        log(toString() + " shut down with error code: " + error);

    if(fm != null)

        fm.close();

    System.exit(error);

}



public void start() {

    try(BufferedReader r = new BufferedReader(new InputStreamReader(System.in))) {

        System.out.print("You: ");

        String s = r.readLine();

        if(respond(s))

            start();

    } catch(Throwable t) {

        printError(t);

    }

}



public boolean respond(String s) { //decide how and what to respond, return if we should keep the program alive

    if(s.trim().equals(""))

        return true; //nothing to do, but keep the program alive

    String response = "";

    if(last == null) { //first message must always be a greeting

        boolean newg = true;

        for(String r : fm.getResponses(ResponseType.GREETING)) {

            if(transform(s).equalsIgnoreCase(transform(r)))

                newg = false; //if this is a greeting that we know about, we dont need to store it again

        }

        if(newg) //store a new greeting for use in another session (or this one)

            fm.setResponse(ResponseType.GREETING, removeEndPunc(s));

        //give a greeting back!

        System.out.println(response = (name + ": " + format(fm.getResponses(ResponseType.GREETING).get((int) (System.nanoTime() % fm.getResponses(ResponseType.GREETING).size())))));

    } else {

        boolean notg = true;

        for(String r : fm.getResponses(ResponseType.GREETING)) { //check if THE LAST MESSAGE is another greeting

            if(transform(last).equalsIgnoreCase(transform(r)))

                notg = false;

        }

        boolean notf = true;

        for(String r : fm.getResponses(ResponseType.FAREWELL)) { //check if they're saying a known farewell

            if(transform(s).equalsIgnoreCase(transform(r)))

                notf = false;

        }

        if((!notf || s.equalsIgnoreCase("exit")) && notg) { //if they're doing a farewell or saying "exit", and THE LAST MESSAGE is not a greeting

            boolean newf = true;

            for(String r : fm.getResponses(ResponseType.FAREWELL)) { //check if it's a new farewell

                if(transform(last).equalsIgnoreCase(transform(r)))

                    newf = false;

            }

            if(newf) //if it's new, store it for another session (or this one)

                fm.setResponse(ResponseType.FAREWELL, removeEndPunc(last));

            //say bye back

            System.out.println(response = (name + ": " + format(fm.getResponses(ResponseType.FAREWELL).get((int) (System.nanoTime() % fm.getResponses(ResponseType.FAREWELL).size())))));

            return false; //exit the loop

        }

    }



    boolean containsLaugh = false;

    for(String r : fm.getResponses(ResponseType.LAUGH)) { //are they laughing?

        if(s.matches(".*?\b" + r + "\b.*?"))

            containsLaugh = true;

    }

    boolean laughIfPossible = false;

    int laugh = 0;

    for(char c : s.toCharArray()) { //very bad laugh detection: >50% h's or l's

        if(c == 'h' || c == 'l')

            laugh++;

    }

    if(laugh > s.toCharArray().length / 2) { //if >50% h's or l's

        boolean newl = true;

        for(String r : fm.getResponses(ResponseType.LAUGH)) { //is this a laugh we know?

            if(transform(s).equalsIgnoreCase(transform(r)))

                newl = false;

        }

        if(newl) //if it's new, save it for later

            fm.setResponse(ResponseType.LAUGH, removeEndPunc(s));

        laughIfPossible = true; //if there's nothing else to say later, laugh

    }



    if(!containsLaugh) { //if super serious business mode is on

        String set = s.split("(\s+is\s+|\'s\s+)"); //regex: split for every "is" or 's ('s as in contraction for is)

        try { //if it's math, solve it

            System.out.println(response = (name + ": " + solve(transform(set[1]).trim())));

        } catch(Throwable t) { //it's not math

            String ek = transform(set[0]).toLowerCase(); //get the first part of the phrase

            if(ek.contains("what")) { //user is asking for information

                String k = transform(reversePerson(join(set, "is", 1).toLowerCase())); //get the object to look up

                for(String values : fm.getResponses(ResponseType.VALUE)) {

                    if(transform(values.split("§=§")[0]).trim().equalsIgnoreCase(k)) //if we know the information, tell the user

                        response = name + ": " + cap(k) + " is " + values.split("§=§")[1].trim() + punc();

                }

                if(!response.equals("")) //only respond if we have something useful to say

                    System.out.println(response);

            } else if(s.contains(" is ")) { //the user is telling us information

                String k = reversePerson(s.split(" is ")[0].toLowerCase().trim()); //the key to store

                String v = join(s.split(" is "), "is", 1).toLowerCase().trim(); //the value to store for the key

                fm.setResponse(ResponseType.VALUE, k + "§=§" + reversePerson(removeEndPunc(v))); //store the key and value

                System.out.println(response = (name + ": " + cap(k) + " is " + removeEndPunc(v) + punc())); //tell the user about our new information

            }

        }

    }

    if(response.trim().equals("") && (laughIfPossible || containsLaugh)) //if we have nothing else to say, but we can laugh, laugh

        System.out.println(response = (name + ": " + cap(fm.getResponses(ResponseType.LAUGH).get((int) (System.nanoTime() % fm.getResponses(ResponseType.LAUGH).size()))))); //say a random laugh

    fm.log("You: " + s); //log what the user said

    fm.log(name + ": " + (response.replace(name + ": ", ""))); //log our response, make sure to include the name even if we didn't earlier

    last = s; //set the new last message

    return true; //keep the program alive

}



private static String join(String set, String medium, int offset) { //join an array together with a specified string in between starting at a specified offset

    String s = set[offset];

    int i = 0;

    for(String part : set) {

        if(i > offset)

            s = s + " " + medium + " " + part;

        i++;

    }

    return s;

}



private static String reversePerson(String s) { //reverse between 1st and 3rd person, so Genesis makes sense

    return s.replaceAll("\byour\b", "§§m§§y§§").replaceAll("\byou\b", "§§m§§e§§").replaceAll("\bme\b", "you").replaceAll("\bmy\b", "your").replaceAll("\byours\b", "§§mi§§ne§§").replaceAll("\bmine\b", "yours").replace("§§", "").trim();

}



public static double solve(String c) { //solve math expressions

    Pattern p = Pattern.compile("(\d+|\d+\.\d+)\s*(\+|\-|\*|\/|\%|\|)\s*(\d+|\d+\.\d+).*"); //<number> <+-*/%|> <number>

    Matcher m = p.matcher(c);

    if(m.matches()) { //if this is a correct math expression

        Double d1 = Double.parseDouble(m.group(1));

        Double d2 = Double.parseDouble(m.group(3));

        while(c.contains("+") || c.contains("-") || c.contains("*") || c.contains("/") || c.contains("%") || c.contains("|")) { //checking for valid operations

            c = c.replaceAll("(\d)\.0(\D)", "$1$2"); //replace all x.0 with just x (it looks better)

            m = p.matcher(c);

            if(!m.matches()) //this SHOULD match

                throw new ArithmeticException();

            switch(m.group(2)) { //check the operation symbol and do math

                default:

                    break;

                case "+":

                    c = c.replaceAll("[" + d1 + "]\s*\+\s*[" + d2 + "]", (d1 + d2) + "");

                    break;

                case "-":

                    c = c.replaceAll("[" + d1 + "]\s*\-\s*[" + d2 + "]", (d1 - d2) + "");

                    break;

                case "*":

                    c = c.replaceAll("[" + d1 + "]\s*\*\s*[" + d2 + "]", (d1 * d2) + "");

                    break;

                case "/":

                    c = c.replaceAll("[" + d1 + "]\s*\/\s*[" + d2 + "]", (d1 / d2) + "");

                    break;

                case "%":

                    c = c.replaceAll("[" + d1 + "]\s*%\s*[" + d2 + "]", (d1 % d2) + "");

                    break;

                case "|":

                    c = c.replaceAll("[" + d1 + "]\s*\|\s*[" + d2 + "]", (Integer.parseInt((d1 + "").replace(".0", "")) | Integer.parseInt((d2 + "").replace(".0", ""))) + "");

                    break;

            }

        }

    } //else, maybe it's just a number (return the number)... or maybe it's not even math - if it is, return the parsed answer

    return Double.parseDouble(c);

}



private static String transform(String s) { //transform a string into something the program can read

    return s.toLowerCase().replace("?", "").replace(".", "").replace("!", "").replace(",", "").replace("_", "").replace("~", "").replace("`", "").replace("'", "").replace(""", "").replace(""", "").replace("\", "").replace(":", "").replace(";", "").replace("the", " ").replace("teh", " ").replace("how do", "how can").replace("re", "").replace(" a ", " ").replace("is", "").replace("has", "").replace("get to", "go to").replaceAll("\Bs\b", "").replaceAll(" {2}?", "").trim();

}



private static String removeEndPunc(String s) {

    return s.replaceAll("[!\.\?]+$", ""); //remove all !'s .'s and ?'s from the end of a string

}



private static String format(String s) { //add random punctuation, and capitalize the first character

    return cap(s) + punc();

}



private static String cap(String s) { //capitalize the first letter of a given string

    String r = s.toUpperCase();

    if(r.length() > 1)

        r = s.replaceFirst(s.substring(0, 1), s.substring(0, 1).toUpperCase());

    return r;

}



private static char punc() { //return random punctuation

    switch((int) System.nanoTime() % 5) {

        default:

        case 0:

        case 1:

        case 2:

        case 3:

            return '.';

        case 4:

            return '!';

    }

}



public FileManager getFileManager() {

    return fm;

}



public void printError(Throwable t) {

    printError(System.err, t);

    if(fm != null)

        printError(fm.getLogStream(), t);

    stop(1);

}



private static void printError(Object output, Throwable t) {

    PrintWriterStream out;

    if(output instanceof PrintWriter)

        out = new PrintWriterStream((PrintWriter) output);

    else if(output instanceof PrintStream)

        out = new PrintWriterStream((PrintStream) output);

    else

        throw new IllegalArgumentException("Output must be of type PrintWriter or PrintStream");

    out.println();

    out.println("A fatal error occurred: " + t.toString());

    out.println();

    out.println("-----=[General Stack Trace]=-----");

    for(StackTraceElement s : t.getStackTrace())

        //print the throwable's stack trace

        out.println(s.getClassName() + "." + s.getMethodName() + "() on line " + s.getLineNumber());

    out.println("-----=[" + name + " Stack Trace]=-----");

    out.println();

    out.println("-----=[" + name + " Stack Trace]=-----");

    boolean fault = false;

    for(StackTraceElement s : t.getStackTrace()) { //filter out the stack trace for only Genesis

        if(s.getClassName().startsWith("genesis")) {

            out.println(s.getClassName() + "." + s.getMethodName() + "() on line " + s.getLineNumber());

            fault = true;

        }

    }

    if(!fault) //if it's not our fault, tell the user

        out.println("This doesn't look like a problem relating to " + name + ". Check the above general stack trace.");

    out.println("-----=[Genesis Stack Trace]=-----");

    out.println();

    out.println("-----=[Remote Stack Trace]=-----");

    fault = false;

    for(StackTraceElement s : t.getStackTrace()) { //filter out the stack trace for only outside Genesis

        if(!s.getClassName().startsWith("genesis")) {

            out.println(s.getClassName() + "." + s.getMethodName() + "() on line " + s.getLineNumber());

            fault = true;

        }

    }

    if(!fault) //if it's not their fault, tell the user

        out.println("This doesn't look like a problem with anything outside " + name + ". Check the above " + name + " stack trace.");

    out.println("-----=[Remote Stack Trace]=-----");

    out.println();

}



public void log(String message) {

    log(System.out, message);

}



public void log(PrintStream out, String message) {

    FileManager.log(out, message);

    if(fm != null)

        fm.log(message);

}



public String toString() {

    return name + " v" + version;

}



static class PrintWriterStream { //super hacky way of combining a PrintWriter and a PrintStream



    private PrintWriter w;

    private PrintStream s;



    PrintWriterStream(PrintWriter w) { //support for PrintWriter

        if(w == null)

            throw new NullPointerException();

        this.w = w;

    }



    PrintWriterStream(PrintStream s) { //support for PrintStream

        if(s == null)

            throw new NullPointerException();

        this.s = s;

    }



    void println() {

        if(w == null && s != null)

            s.println();

        else if(s == null && w != null)

            w.println();

        else

            throw new NullPointerException("No valid output");

    }



    void println(String x) {

        if(w == null && s != null)

            s.println(x);

        else if(s == null && w != null)

            w.println(x);

        else

            throw new NullPointerException("No valid output");

    }



    public void flush() {

        if(w == null && s != null)

            s.flush();

        else if(s == null && w != null)

            w.flush();

        else

            throw new NullPointerException("No valid output");

    }

}



}

FileManager.java

package genesis;



import genesis.Genesis.PrintWriterStream;



import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.PrintStream;

import java.io.PrintWriter;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.HashMap;

import java.util.List;



public final class FileManager {



private final Genesis g;

public static final String folderPath = "Genesis/";

private final File folder = new File(folderPath);

private final File log = new File(folderPath + "log.txt");

private final File resp = new File(folderPath + "responses.txt");

private final PrintWriter lout;

private final PrintWriter rout;



public FileManager(Genesis g) throws IOException {

    this.g = g;

    folder.mkdirs(); //make the Genesis folder if it doesn't exist

    checkFiles(); //make the files

    lout = new PrintWriter(new FileWriter(log, true));

    rout = new PrintWriter(new FileWriter(resp, true));

}



private void checkFiles() { //create new log and response files if they don't exist

    try {

        if (!log.exists())

            log.createNewFile();

        if (!resp.exists())

            resp.createNewFile();

    } catch (IOException e) {

        g.printError(e);

    }

}



public Genesis getGenesis() {

    return g;

}



public File getFolder() {

    return folder;

}



public File getLog() {

    return log;

}



public File getResponsesFile() {

    return resp;

}



public HashMap<ResponseType, List<String>> getResponses() { //get a hashmap of all responsetypes and responses for that type in list form

    checkFiles(); //make sure our files exist first

    HashMap<ResponseType, List<String>> res = new HashMap<ResponseType, List<String>>();

    if (resp.length() == 0) //if we don't have anything, don't return anything

        return res;

    try (BufferedReader r = new BufferedReader(new FileReader(resp))) {

        String line;

        while ((line = r.readLine()) != null) {

            for (ResponseType rt : ResponseType.values()) {

                if (line.split("�")[0].equalsIgnoreCase(rt.name())) { //I could use a different character... but it kept changing back when I moved the project between computers

                    String response = "";

                    for (int i = 1; i < line.split("�").length; i++)

                        response = line.split("�")[i].trim();

                    if (res.get(rt) == null) {

                        List<String> list = new ArrayList<String>();

                        list.add(response);

                        res.put(rt, list);

                    } else

                        res.get(rt).add(response);

                }

            }

        }

    } catch (IOException e) {

        g.printError(e);

    }

    return res;

}



public List<String> getResponses(ResponseType rt) { //get all the responses in list form for a certain response type

    checkFiles();

    List<String> res = new ArrayList<String>();

    if (resp.length() == 0)

        return res;

    try (BufferedReader r = new BufferedReader(new FileReader(resp))) {

        String line;

        while ((line = r.readLine()) != null) {

            if (line.split("�")[0].equalsIgnoreCase(rt.name()))

                res.add(line.split("�")[1].trim());

        }

    } catch (Throwable t) {

        g.printError(t);

    }

    return res;

}



public void setResponse(ResponseType type, String response) { //set a response for a certain type

    response = response.trim();

    try (BufferedReader r = new BufferedReader(new FileReader(resp))) {

        String s;

        while ((s = r.readLine()) != null) {

            if (s.equals(type.toString() + "� " + response))

                return;

        }

        rout.println(type.toString() + "� " + response);

        rout.flush();

    } catch (Throwable t) {

        g.printError(t);

    }

}



public void log(String message) {

    log(lout, message);

}



public static void log(Object output, String message) {

    PrintWriterStream out;

    if(output instanceof PrintWriter)

        out = new PrintWriterStream((PrintWriter) output);

    else if(output instanceof PrintStream)

        out = new PrintWriterStream((PrintStream) output);

    else

        throw new IllegalArgumentException("Output must be of type PrintWriter or PrintStream");

    Calendar c = Calendar.getInstance();

    String hour = c.get(Calendar.HOUR) + "";

    String minute = c.get(Calendar.MINUTE) + "";

    String second = c.get(Calendar.SECOND) + "";

    int ampm = c.get(Calendar.AM_PM);



    if(Integer.parseInt(hour) < 10) //keep the hours minutes and seconds 2 digits

        hour = "0" + hour;

    if(Integer.parseInt(minute) < 10)

        minute = "0" + minute;

    if(Integer.parseInt(second) < 10)

        second = "0" + second;



    String timestamp = "[" + hour + ":" + minute + ":" + second + ":" + (ampm == 0 ? "AM" : "PM") + "]";



    out.println(timestamp + ": " + message);

    out.flush();

}



public PrintWriter getLogStream() {

    return lout;

}



public PrintWriter getResponseStream() {

    return rout;

}



public void close() { //close the log and response file streams

    lout.close();

    rout.close();

}



}

ResponseType.java

package genesis;



public enum ResponseType {



    GREETING, FAREWELL, VALUE, LAUGH;



    public String toString() {

        return name().toLowerCase().replaceFirst(name().substring(0, 1).toLowerCase(), name().substring(0, 1).toUpperCase());

    }



    public static ResponseType getResponseType(String name) {

        for (ResponseType r : values()) {

            if(r.name().equalsIgnoreCase(name))

                return r;

        }

        return null;

    }



}

As a side note, you can compile this code yourself and export it as a runnable JAR file. It creates a folder called Genesis wherever the JAR is, which consists of a log.txt file and a responses.txt file. Log file is what you think it is, and responses file is for use by Genesis, so it knows how to respond to you over time.

Rules for talking to it correctly are as follows:

• First message must be a greeting (hello/hi/etc)


• Last message must be a farewell (goodbye/bye/etc)


• After your farewell, type "exit" to exit the program correctly