path: root/hexfool.go

package main

import (
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
    "golang.org/x/crypto/bcrypt"

    "net/http"
    "strings"
    "os/exec"
    "encoding/json"
    _ "strconv"
    "fmt"
    "io"
    "time"
)

var db *sql.DB
var err error

type UserIdent struct {
    Name string
    Token string
    Action string
    level int
    experience int
    //Token []byte
    //lastact int
}

type Area struct {
    coord_x int
    coord_y int
    coord_z int
    created string
    player  string
    terrtype int
    wealth int
}

type Map []Area

func signupPage(res http.ResponseWriter, req *http.Request) {
    if req.Method != "POST" {
        http.ServeFile(res, req, "html/signup.html")
        return
    }

    username := req.FormValue("username")
    password := req.FormValue("password")
    email := req.FormValue("email")
    var user string

    err := db.QueryRow("SELECT username FROM players WHERE username=?",username).Scan(&user)

    switch {
    case err == sql.ErrNoRows:
        hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
        if err != nil {
            http.Error(res, "Server Error creating Password. Unable to create account! You Fool...", 500)
            Log("ERROR 500 - Hash generation Failed")
            panic(err)
            return
        }
        //newuuid, uiderr := exec.Command("uuidgen").Output()
        //if uiderr != nil{
        //    http.Error(res, "Server Error creating UUID. Unable to create account! You Fool...", 500)
        //    Log("ERROR 500 - Creating UUID failed")
        //    panic(uiderr)
        //    return
        //}

        _, err = db.Exec("INSERT INTO players(username, password, email,level,experience) VALUES(?, ?, ?, ?, ?)", username, hashedPassword, email, 1, 0)
        if err != nil {
            http.Error(res, "Server Error Inserting User. Unable to create account! You Fool...", 500)
            Log("ERROR adding user"+username)
            panic(err)
            //fmt.Println("Error adding User",username)
            return
        }
        res.Write([]byte("User Created Successfully!"))
        Log("Successfully Created User"+username+" email:"+email)
        //fmt.Println("Successfully Created User",username,newuuid)
        return
    case err != nil:
        http.Error(res, "Server Error! Something fucked up", 500)
        Log("ERROR Something fucked up")
        panic(err)
        return
    default:
        http.Redirect(res, req, "/", 301)
    }
}

func loginPage(res http.ResponseWriter, req *http.Request) {
    if req.Method != "POST" {
        http.ServeFile(res, req, "html/login.html")
        return
    }

    username := req.FormValue("username")
    password := req.FormValue("password")

    var databaseUsername string
    var databasePassword string
    var databaseLevel int
    var databaseExp int
//    var databaseUUID string

    err := db.QueryRow("SELECT username, password, level, experience FROM players WHERE username=?", username).Scan(&databaseUsername, &databasePassword, &databaseLevel, &databaseExp)

    if err != nil {
        http.Redirect(res, req, "/login", 301)
        Log("Failed Login atempt by "+username+" ;"+err.Error())
        //fmt.Println("Failed Login atempt by",username)
        return
    }

    err = bcrypt.CompareHashAndPassword([]byte(databasePassword), []byte(password))
    if err != nil {
        http.Redirect(res, req, "/login", 301)
        Log(username+" used wrong Password "+password)
        panic(err)
        //fmt.Println(username," used wrong Password ",password)
        return
    }
    tok, uiderr := getToken()
    token := strings.TrimRight(string(tok), "\n")
    if uiderr != nil{
        http.Error(res, "Server Error creating Token. You Fool...", 500)
            Log("ERROR 500 - Creating UUID failed")
            panic(uiderr)
            return
        }
    type userAction struct {
        Name    string
        Token   string
        Action  string
    }
    useract := userAction{
        Name:       username,
        Token:      token,
        Action:     "nil",
    }
    jout, err := json.Marshal(useract)
    if err != nil {
        Log("Error:"+ err.Error())
    }
    //jout := map[string]string {
    //    "Name":username,
    //    "Token":token,
    //}
    //fmt.Println(databaseLevel,databaseExp)
    keynam := username + "_token"
    setRed(keynam,token,600)
    keynam = username + "_lvl"
    setRed(keynam,databaseLevel,0)
    keynam = username + "_xp"
    setRed(keynam,databaseExp,0)

    res.Write([]byte(string(jout)+" \n\n Have a RESTful party at /game"))
    //res.Write([]byte("Hello "+ databaseUsername + "! Your token is "+ string(tok)))
        Log("Successful Login by "+username)
        //fmt.Println("Successful Login by",username)
}

func getToken() ([]byte, error) {
    newuuid, uiderr := exec.Command("uuidgen").Output()
    return newuuid, uiderr
}

func homePage(res http.ResponseWriter, req *http.Request) {
    http.ServeFile(res, req, "html/index.html")
}

func gamePage(res http.ResponseWriter, req *http.Request) {
    if req.Method != "POST" {
        res.Write([]byte("Access Denied"))
        Log("Attempted Access to Game")
        //http.ServeFile(res, req, "html/login.html")
        return
    }

    //make byte array
    out := make([]byte,1024)
    //
    bodyLen, err := req.Body.Read(out)
    if err != io.EOF {
        fmt.Println(err.Error())
        res.Write([]byte("{error:" + err.Error() + "}"))
        return
    }

    var k UserIdent
    err = json.Unmarshal(out[:bodyLen],&k)
    if err != nil {
        res.Write([]byte("{error:" + err.Error() + "}"))
        return
    }
    //fmt.Println(k.Name, k.Token)
    if !checkLegit(k) {
        Log(k.Name +" token Missing")
        return
    } //else{
       // fmt.Println("Nice")
        //}
    //somemap := false
    var mymap Map
    for {
        mymap = getSQLMap(k.Name)
        if mymap == nil {
        //so := getNewArea(0,0,k.Name)
        //fmt.Println("New:",so)
            if !addSQLMap(getNewArea(0,0,0,k.Name)) {
                return
            }
        }
        break
    }
    fmt.Println("MyMap:",mymap)
    testEngine()
}

func getSQLMap(nam string) Map {
    var rmap Map
    results,err := db.Query("SELECT coord_x, coord_y, coord_z, created, player, terrtype, wealth  FROM maps WHERE player=?",nam)
    if err != nil {
        panic(err.Error())
    }
    i := 0
    for results.Next(){
        i++
        var tf Area
        err = results.Scan(&tf.coord_x, &tf.coord_y, &tf.coord_z, &tf.created, &tf.player, &tf.terrtype, &tf.wealth)
        if err != nil {
            panic(err.Error())
        }
        rmap=append(rmap,tf)
    }
    if i==0 {
        Log(nam + " Has Empty Map.")
        return nil
    }
    return rmap
}

func addSQLMap(newar Area) bool {
    _, err = db.Exec("INSERT INTO maps(coord_x, coord_y, player, terrtype, wealth) VALUES(?, ?, ?, ?, ?)", newar.coord_x, newar.coord_y, newar.player, newar.terrtype, newar.wealth)
    if err != nil {
        Log("ERROR adding area for user "+newar.player)
        panic(err)
        return false
    }
    return true
}

func checkLegit(usr UserIdent) bool{
    namet := usr.Name+"_token"

    if usr.Token == getRed(namet) {
        return true
    }
    return false
    //fmt.Println(getRed(namet))
}

func main() {
    //var tstart time
    
    tstart := time.Now()
    fmt.Println("Hexfool startet at", tstart)

    defer fmt.Println("Goodbye!  Uptime", (time.Now().Second()-tstart.Second()))
    //defer(tend := time.Now()-tstart)
    

    db, err = sql.Open("mysql", "hexmaster:waSIdocHneTdUobeRoarscH@tcp(192.168.0.16)/hexmaster")
    if err != nil {
        panic(err.Error())
    }
    defer db.Close()

    err = db.Ping()
    if err != nil {
        panic(err.Error())
    }

    http.HandleFunc("/signup", signupPage)
    http.HandleFunc("/login", loginPage)
    http.HandleFunc("/game", gamePage)
    http.HandleFunc("/", homePage)
    http.ListenAndServe(":8088", nil)
}