Optimizer code optimized. It is a bit faster now, less verbose, and the code has been documented. More messages are presented to the user, and there is also a log window now.

application/Controller.php

@@ -125,17 +125,6 @@
                         action();
                         return;
                         break;
-                    case "OPTIMIZE":
-                        require_once(PATH::ACTION . "optimize.php");
-                        $response = action();
-                        if (strlen($response) > 1){
-                            echo($response);
-                            return;
-                        }
-                        else{
-                            return;
-                        }
-                        break;
                     case "OPTIMIZE_GET_RUNE_LIST":
                         require_once(PATH::ACTION . "optimize_get_rune_list.php");
                         $response = action();

application/action/optimize.php

@@ -1,649 +0,0 @@
-<?php
-
-    /**
-     * File for the optimization action.
-     *
-     * Implements an action function to be called from the {@see Controller}.
-     * 
-     * @category Action
-     */
-
-    /**
-     * Executes the optimization action.
-     *
-     * Reads the POST parameters looking for the following KEYS:
-     *  mail
-     *  pass + currentPass
-     *  api
-     * Then it updates the selected info with the prameter vlue. Multiple
-     * itemas can be updated at the same time.
-     * 
-     * @return int|string 0 on success, negative values on error. If the API
-     * key has been updated, the new key.
-     * @category Action
-     * @global resource Database connection.
-     */
-    function action(){
-
-        global $db;
-        
-        $HARD_LIMIT = 100;
-
-        // Increase max execution time.
-        set_time_limit(60);
-        
-        $candidates = [
-            1 => [],
-            2 => [],
-            3 => [],
-            4 => [],
-            5 => [],
-            6 => []
-        ];
-        
-        $options = [];
-
-        $response = null;
-
-        $uid = filter_input(INPUT_POST, 'uid');
-        if ($uid == null){
-            return -1;
-        }
-
-        $unit_id = filter_input(INPUT_POST, 'unit');
-        if ($unit_id == null){
-            return -2;
-        }
-
-        // Sets
-        $sets = [];
-        foreach ($_POST["set"] as $x){
-            array_push($sets, intval($x));
-        }
-        if (sizeof($sets) < 2 || sizeof($sets) > 3){
-            return -3;
-        }
-
-        // Main stats in even slots.
-        $stats = [];
-        foreach ($_POST["stat"] as $x){
-            array_push($stats, intval($x));
-        }
-
-        $source = filter_input(INPUT_POST, 'source');
-        if ($source == null){
-            return -4;
-        }
-        
-        $limit = intval(filter_input(INPUT_POST, 'limit'));
-        if ($limit == 0){
-            return -5;
-        }
-
-        $tuning = filter_input(INPUT_POST, 'tuning');
-        if ($tuning == null){
-            return -6;
-        }
-        
-        $min = [
-            "attack" => intval(filter_input(INPUT_POST, 'min_attack')),
-            "defense" => intval(filter_input(INPUT_POST, 'min_defense')),
-            "hp" => intval(filter_input(INPUT_POST, 'min_hp')),
-            "speed" => intval(filter_input(INPUT_POST, 'min_speed')),
-            "crit_rate" => intval(filter_input(INPUT_POST, 'min_crit_rate')),
-            "crit_damage" => intval(filter_input(INPUT_POST, 'min_crit_damage')),
-            "accuracy" => intval(filter_input(INPUT_POST, 'min_accuracy')),
-            "resistance" => intval(filter_input(INPUT_POST, 'min_resistance')),
-            "ehp" => intval(filter_input(INPUT_POST, 'min_ehp')),
-            "dmg" => intval(filter_input(INPUT_POST, 'min_dmg'))
-        ];
-
-        // Get Buld query:
-        $base_s = "
-          SELECT
-            id,
-            slot
-          FROM rune
-          WHERE
-            uid = $uid AND
-            type IN (
-        ";
-        foreach ($sets as $set){
-            $base_s .= ($set . ",");
-        }
-        $base_s .= "-1) AND ";
-        switch ($source){
-            case 0: // Storage only (or itself)
-                $base_s .= "
-                  (
-                    assigned_to = $unit_id OR
-                    assigned_to IS NULL
-                  )";
-                break;
-            case 1: // Units in no teams (or itself)
-                $base_s .= "
-                  (
-                    assigned_to = $unit_id OR
-                    assigned_to IS NULL OR 
-                    assigned_to NOT IN (SELECT DISTINCT unit FROM team_unit)
-                  )
-                ";
-                break;
-            case 2: // Units in teams with 0 score (or itself)
-                $base_s .= "
-                  (
-                    assigned_to = $unit_id OR
-                    assigned_to IS NULL OR 
-                    assigned_to NOT IN (SELECT DISTINCT unit FROM team_unit) OR
-                    assigned_to NOT IN (
-                      SELECT DISTINCT unit 
-                      FROM
-                        team,
-                        team_unit
-                      WHERE
-                        team.id = team_unit.team AND
-                        team.score > 0
-                    )
-                  )
-                ";
-                break;
-            case 3: // Units with lower overall score (or itself)
-                // TODO
-                break;
-            case 4: // All runes - dont filter
-                $base_s .= " 1 = 1 ";
-                break;
-            default: // Invalid options - return nothing
-                $base_s .= " 1 = 0 ";
-        }
-        $s_order = " ORDER BY stars DESC, original_quality DESC, max_efficiency DESC, efficiency DESC, level DESC";
-
-        $s = ["", "", "", "", "", "", ""];
-        $s[1] = $base_s . " AND slot = 1 " . $s_order . " LIMIT 25";
-        $s[3] = $base_s . " AND slot = 3 " . $s_order . " LIMIT 25";
-        $s[5] = $base_s . " AND slot = 5 " . $s_order . " LIMIT 25";
-        $s[2] = $base_s . " AND slot = 2 AND main_stat = " . $stats[0] . $s_order . " LIMIT 20";
-        $s[4] = $base_s . " AND slot = 4 AND main_stat = " . $stats[1] . $s_order . " LIMIT 20";
-        $s[6] = $base_s . " AND slot = 6 AND main_stat = " . $stats[2] . $s_order . " LIMIT 20";
-
-        $total_candidates = 0;
-        for ($i = 1; $i <= 6; $i ++){
-            $q = $db->query($s[$i]);
-            while ($r = $q->fetchArray(SQLITE3_ASSOC)){
-                array_push($candidates[$i], new Rune($r["id"]));
-                $total_candidates ++;
-            }
-        }
-        $max_combinations = sizeof($candidates[1]) * sizeof($candidates[2]) * sizeof($candidates[3]) * sizeof($candidates[4]) * sizeof($candidates[5]) * sizeof($candidates[6]);
-        if ($max_combinations == 0){
-            $res = [
-                "total" => 0,
-                "options" => []
-            ];
-            $response = json_encode($res);
-            return $response;
-        }
-        elseif ($max_combinations > 125000000){
-            // This should never happen unles query limits are changed
-            http_response_code(413); // Payload too large;
-            die();
-            return;
-        }
-        
-        // Get the unit and its base stats
-        $unit = new Unit($unit_id, true, $uid);
-        $unit_attack = $unit->attack + $unit->artifact_attack + $unit->building_attack;
-        $unit_base_attack = $unit->attack;
-        $unit_defense = $unit->defense + $unit->artifact_defense + $unit->building_defense;
-        $unit_base_defense = $unit->defense;
-        $unit_hp = $unit->hp + $unit->artifact_hp + $unit->building_hp;
-        $unit_base_hp = $unit->hp;
-        $unit_speed = $unit->speed + $unit->artifact_speed + $unit->building_speed;
-        $unit_base_speed = $unit->speed;
-        $unit_crit_rate = $unit->crit_rate + $unit->artifact_crit_rate + $unit->building_crit_rate;
-        $unit_base_crit_rate = $unit->crit_rate;
-        $unit_crit_damage = $unit->crit_damage + $unit->artifact_crit_damage + $unit->building_crit_damage;
-        $unit_base_crit_damage = $unit->crit_damage;
-        $unit_accuracy = $unit->accuracy + $unit->artifact_accuracy + $unit->building_accuracy;
-        $unit_base_accuracy = $unit->accuracy;
-        $unit_resistance = $unit->resistance + $unit->artifact_resistance + $unit->building_resistance;
-        $unit_base_resistance = $unit->resistance;
-
-        $i = [0, 0, 0, 0, 0, 0, 0]; // 7, so I can start with 1
-        while (true){
-            
-            
-            // Check if set combination is valid
-            if (valid_sets($candidates, $i, $sets) == true){
-                // Do things
-                $iteration = [
-                    "attack" => $unit_attack,
-                    "defense" => $unit_defense,
-                    "hp" => $unit_hp,
-                    "speed" => $unit_speed,
-                    "crit_rate" => $unit_crit_rate,
-                    "crit_damage" => $unit_crit_damage,
-                    "accuracy" => $unit_accuracy,
-                    "resistance" => $unit_resistance,
-                    "ehp" => 0,
-                    "dmg" => 0,
-                ];
-                for ($r = 1; $r <= 6; $r ++){
-                    // Loop selected runes and calculate stats
-                    $main_value = $candidates[$r][$i[$r]]->main_stat_value;
-                    if ($tuning == 1){ // All +12
-                        if ($candidates[$r][$i[$r]]->level < 12){
-                            $main_value = $candidates[$r][$i[$r]]->get_main_stat_at_level(12);
-                        }
-                    }
-                    elseif ($tuning == 2){ // Even +15, Odd + 12
-                        if ($candidates[$r][$i[$r]]->level < 15 && $candidates[$r][$i[$r]]->slot % 2 == 0){
-                            $main_value = $candidates[$r][$i[$r]]->get_main_stat_at_level(15);
-                        }
-                        elseif ($candidates[$r][$i[$r]]->level < 12 && $candidates[$r][$i[$r]]->slot % 2 != 0){
-                            $main_value = $candidates[$r][$i[$r]]->get_main_stat_at_level(12);
-                        }
-                    }
-                    if ($tuning == 3){ // All +15
-                        if ($candidates[$r][$i[$r]]->level < 15){
-                            $main_value = $candidates[$r][$i[$r]]->get_main_stat_at_level(15);
-                        }
-                    }
-                    sum_rune_stat(
-                      $candidates[$r][$i[$r]]->main_stat,
-                      $main_value,
-                      $iteration,
-                      $unit_base_attack,
-                      $unit_base_defense,
-                      $unit_base_hp,
-                    );
-                    sum_rune_stat(
-                      $candidates[$r][$i[$r]]->innate_stat,
-                      $candidates[$r][$i[$r]]->innate_stat_value,
-                      $iteration,
-                      $unit_base_attack,
-                      $unit_base_defense,
-                      $unit_base_hp,
-                    );
-                    sum_rune_stat(
-                      $candidates[$r][$i[$r]]->substat_1,
-                      $candidates[$r][$i[$r]]->substat_1_value,
-                      $iteration,
-                      $unit_base_attack,
-                      $unit_base_defense,
-                      $unit_base_hp,
-                    );
-                    sum_rune_stat(
-                      $candidates[$r][$i[$r]]->substat_2,
-                      $candidates[$r][$i[$r]]->substat_2_value,
-                      $iteration,
-                      $unit_base_attack,
-                      $unit_base_defense,
-                      $unit_base_hp,
-                    );
-                    sum_rune_stat(
-                      $candidates[$r][$i[$r]]->substat_3,
-                      $candidates[$r][$i[$r]]->substat_3_value,
-                      $iteration,
-                      $unit_base_attack,
-                      $unit_base_defense,
-                      $unit_base_hp,
-                    );
-                    sum_rune_stat(
-                      $candidates[$r][$i[$r]]->substat_4,
-                      $candidates[$r][$i[$r]]->substat_4_value,
-                      $iteration,
-                      $unit_base_attack,
-                      $unit_base_defense,
-                      $unit_base_hp,
-                    );
-                }
-                
-                // Calculate effective_hp
-                $hp = $iteration["hp"];
-                $def = $iteration["defense"];
-                $ehp = ceil(((($def * 3.5) + 1140) * $hp) / 1000);
-                $iteration["ehp"] = $ehp;
-
-                // Calculate effective_dmg
-                $atk = $iteration["attack"];
-                $crr = $iteration["crit_rate"];
-                if ($crr > 100){
-                    $crr = 100;
-                }
-                $crd = $iteration["crit_damage"];
-                $edmg = ceil(($atk * (100 - $crr) / 100) + (($atk + ($atk * $crd / 100)) * $crr / 100));
-                $iteration["dmg"] = $edmg;
-
-                // Compare with filters:
-                if (
-                  $iteration["attack"] >= $min["attack"] &&
-                  $iteration["defense"] >= $min["defense"] &&
-                  $iteration["hp"] >= $min["hp"] &&
-                  $iteration["speed"] >= $min["speed"] &&
-                  $iteration["crit_rate"] >= $min["crit_rate"] &&
-                  $iteration["crit_damage"] >= $min["crit_damage"] &&
-                  $iteration["accuracy"] >= $min["accuracy"] &&
-                  $iteration["resistance"] >= $min["resistance"] &&
-                  $iteration["ehp"] >= $min["ehp"] &&
-                  $iteration["dmg"] >= $min["dmg"]
-                ){
-
-                    // Calculate the variation
-                    $variation = 0;
-                    $variation += (($iteration["attack"] - $unit->total_attack) * 1);
-                    $variation += (($iteration["defense"] - $unit->total_defense) * 1);
-                    $variation += (($iteration["hp"] - $unit->total_hp) * (1 / 15));
-                    $variation += (($iteration["speed"] - $unit->total_speed) * 1.5);
-                    $variation += (($iteration["crit_rate"] - $unit->total_crit_rate) * 0.85);
-                    $variation += (($iteration["crit_damage"] - $unit->total_crit_damage) * 0.9);
-                    $variation += (($iteration["accuracy"] - $unit->total_accuracy) * 0.85);
-                    $variation += (($iteration["resistance"] - $unit->total_resistance) * 0.85);
-                    $variation = ceil($variation);
-
-                    // Calculate efficiency
-                    $efficiency = 0;
-                    
-                    // Build the array
-                    $option = [
-                        "variation" => $variation,
-                        "runes" => [
-                            [
-                                "id" => $candidates[1][$i[1]]->id,
-                                "html" => (HTML::rune_table($candidates[1][$i[1]]))
-                            ],
-                            [
-                                "id" => $candidates[2][$i[2]]->id,
-                                "html" => (HTML::rune_table($candidates[2][$i[2]]))
-                            ],
-                            [
-                                "id" => $candidates[3][$i[3]]->id,
-                                "html" => (HTML::rune_table($candidates[3][$i[3]]))
-                            ],
-                            [
-                                "id" => $candidates[4][$i[4]]->id,
-                                "html" => (HTML::rune_table($candidates[4][$i[4]]))
-                            ],
-                            [
-                                "id" => $candidates[5][$i[5]]->id,
-                                "html" => (HTML::rune_table($candidates[5][$i[5]]))
-                            ],
-                            [
-                                "id" => $candidates[1][$i[1]]->id,
-                                "html" => HTML::rune_table($candidates[6][$i[6]])
-                            ]
-                        ],
-                        "stats" => [
-                            "attack" => ceil($iteration["attack"]),
-                            "defense" => ceil($iteration["defense"]),
-                            "hp" => ceil($iteration["hp"]),
-                            "speed" => ceil($iteration["speed"]),
-                            "crit_rate" => ceil($iteration["crit_rate"]),
-                            "crit_damage" => ceil($iteration["crit_damage"]),
-                            "accuracy" => ceil($iteration["accuracy"]),
-                            "attack" => ceil($iteration["attack"]),
-                            "resistance" => ceil($iteration["resistance"]),
-                            "ehp" => ceil($iteration["ehp"]),
-                            "dmg" => ceil($iteration["dmg"])
-                        ]
-                    ];
-                    array_push($options, $option);
-                    if (sizeof($options) > 5000){
-                        http_response_code(413); // Payload too large;
-                        die();
-                        return;
-                    }
-                }
-
-            }
-
-            // Increase counters
-            $i[6] ++;
-            if ($i[6] == sizeof($candidates[6])){
-                $i[6] = 0;
-                $i[5] ++;
-            }
-            if ($i[5] == sizeof($candidates[5])){
-                $i[5] = 0;
-                $i[4] ++;
-            }
-            if ($i[4] == sizeof($candidates[4])){
-                $i[4] = 0;
-                $i[3] ++;
-            }
-            if ($i[3] == sizeof($candidates[3])){
-                $i[3] = 0;
-                $i[2] ++;
-            }
-            if ($i[2] == sizeof($candidates[2])){
-                $i[2] = 0;
-                $i[1] ++;
-            }
-
-            // Calculate exit condition
-            if (
-                $i[1] >= sizeof($candidates[1]) - 1 &&
-                $i[2] >= sizeof($candidates[2]) - 1 &&
-                $i[3] >= sizeof($candidates[3]) - 1 &&
-                $i[4] >= sizeof($candidates[4]) - 1 &&
-                $i[5] >= sizeof($candidates[5]) - 1 &&
-                $i[6] >= sizeof($candidates[6]) - 1
-            ){
-                break;
-            }
-        }
-
-        // Sort options by variation
-        usort($options, "sortOptions");
-
-        // Limit the array to the top options
-        $original_options_size = sizeof($options);
-        while (sizeof($options) > $limit || sizeof($options) > $HARD_LIMIT){
-            array_pop($options);
-        }
-        
-        
-        $res = [
-            "total" => sizeof($options),
-            "skipped" => ($original_options_size - sizeof($options)),
-            "options" => $options
-        ];
-        
-        $response = json_encode($res);
-        if ($response == null){
-            return 0;
-        }
-        else{
-            return $response;
-        }
-    }
-    
-    /**
-     * Validates a rune combination.
-     *
-     * Checks that set numbers are OK.
-     *
-     * @param \Rune[][] $candidates Candidate runes.
-     * @param int[] $indexes Currently selected indexes.
-     */
-    function valid_sets($candidates, $indexes, $requested){
-        
-        $sets = [
-            RUNE_SET_ID::ENERGY => 0,
-            RUNE_SET_ID::GUARD => 0,
-            RUNE_SET_ID::SWIFT => 0,
-            RUNE_SET_ID::BLADE => 0,
-            RUNE_SET_ID::RAGE => 0,
-            RUNE_SET_ID::FOCUS => 0,
-            RUNE_SET_ID::ENDURE => 0,
-            RUNE_SET_ID::FATAL => 0,
-            RUNE_SET_ID::DESPAIR => 0,
-            RUNE_SET_ID::VAMPIRE => 0,
-            RUNE_SET_ID::VIOLENT => 0,
-            RUNE_SET_ID::NEMESIS => 0,
-            RUNE_SET_ID::WILL => 0,
-            RUNE_SET_ID::SHIELD => 0,
-            RUNE_SET_ID::REVENGE => 0,
-            RUNE_SET_ID::DESTROY => 0,
-            RUNE_SET_ID::FIGHT => 0,
-            RUNE_SET_ID::DETERMINATION => 0,
-            RUNE_SET_ID::ENHANCE => 0,
-            RUNE_SET_ID::ACCURACY => 0,
-            RUNE_SET_ID::TOLERANCE => 0
-        ];
-        for ($i = 1; $i <= 6; $i++){
-            $sets[$candidates[$i][$indexes[$i]]->type->id] ++;
-        }
-        for ($i = 0; $i < sizeof($sets); $i ++){
-            switch ($i){
-                case RUNE_SET_ID::ENERGY:
-                case RUNE_SET_ID::GUARD:
-                case RUNE_SET_ID::NEMESIS:
-                case RUNE_SET_ID::BLADE:
-                case RUNE_SET_ID::FOCUS:
-                case RUNE_SET_ID::ENDURE:
-                case RUNE_SET_ID::WILL:
-                case RUNE_SET_ID::SHIELD:
-                case RUNE_SET_ID::REVENGE:
-                case RUNE_SET_ID::DESTROY:
-                case RUNE_SET_ID::FIGHT:
-                case RUNE_SET_ID::DETERMINATION:
-                case RUNE_SET_ID::ENHANCE:
-                case RUNE_SET_ID::ACCURACY:
-                case RUNE_SET_ID::TOLERANCE:
-                    if ($sets[$i] % 2 != 0){
-                        return false;
-                    }
-                    break;
-                
-                case RUNE_SET_ID::DESPAIR:
-                case RUNE_SET_ID::SWIFT:
-                case RUNE_SET_ID::RAGE:
-                case RUNE_SET_ID::FATAL:
-                case RUNE_SET_ID::VAMPIRE:
-                case RUNE_SET_ID::VIOLENT:
-                    if ($sets[$i] != 4 && $sets[$i != 0]){
-                        return false;
-                    }
-                    break;
-            }
-        }
-
-        // Sets are valid, now check if they comply with filters
-        $requested_sets = [
-            RUNE_SET_ID::ENERGY => 0,
-            RUNE_SET_ID::GUARD => 0,
-            RUNE_SET_ID::SWIFT => 0,
-            RUNE_SET_ID::BLADE => 0,
-            RUNE_SET_ID::RAGE => 0,
-            RUNE_SET_ID::FOCUS => 0,
-            RUNE_SET_ID::ENDURE => 0,
-            RUNE_SET_ID::FATAL => 0,
-            RUNE_SET_ID::DESPAIR => 0,
-            RUNE_SET_ID::VAMPIRE => 0,
-            RUNE_SET_ID::VIOLENT => 0,
-            RUNE_SET_ID::NEMESIS => 0,
-            RUNE_SET_ID::WILL => 0,
-            RUNE_SET_ID::SHIELD => 0,
-            RUNE_SET_ID::REVENGE => 0,
-            RUNE_SET_ID::DESTROY => 0,
-            RUNE_SET_ID::FIGHT => 0,
-            RUNE_SET_ID::DETERMINATION => 0,
-            RUNE_SET_ID::ENHANCE => 0,
-            RUNE_SET_ID::ACCURACY => 0,
-            RUNE_SET_ID::TOLERANCE => 0
-        ];
-        for ($i = 0; $i < sizeof($requested); $i ++){
-            switch ($requested[$i]){
-                case RUNE_SET_ID::ENERGY:
-                case RUNE_SET_ID::GUARD:
-                case RUNE_SET_ID::NEMESIS:
-                case RUNE_SET_ID::BLADE:
-                case RUNE_SET_ID::FOCUS:
-                case RUNE_SET_ID::ENDURE:
-                case RUNE_SET_ID::WILL:
-                case RUNE_SET_ID::SHIELD:
-                case RUNE_SET_ID::REVENGE:
-                case RUNE_SET_ID::DESTROY:
-                case RUNE_SET_ID::FIGHT:
-                case RUNE_SET_ID::DETERMINATION:
-                case RUNE_SET_ID::ENHANCE:
-                case RUNE_SET_ID::ACCURACY:
-                case RUNE_SET_ID::TOLERANCE:
-                    $requested_sets[$requested[$i]] += 2;
-                    break;
-                case RUNE_SET_ID::DESPAIR:
-                case RUNE_SET_ID::SWIFT:
-                case RUNE_SET_ID::RAGE:
-                case RUNE_SET_ID::FATAL:
-                case RUNE_SET_ID::VAMPIRE:
-                case RUNE_SET_ID::VIOLENT:
-                    $requested_sets[$requested[$i]] += 4;
-                    break;
-            }
-        }
-
-        if ($sets === $requested_sets){
-            return true;
-        }
-        else{
-            return false;
-        }
-    }
-
-    /**
-     * Calculates the stat increase by a rune property.
-     * 
-     * @param string $stat Stat type.
-     * @param int $value Stat increase value.
-     * @param int[] Reference to iteration stats array.
-     */
-    function sum_rune_stat($stat, $value, &$iteration, $base_atk, $base_def, $base_hp){
-        switch ($stat){
-            case RUNE_STAT_ID::ATK:
-                $iteration["attack"] += $value;
-                break;
-            case RUNE_STAT_ID::DEF:
-                $iteration["defense"] += $value;
-                break;
-            case RUNE_STAT_ID::HP:
-                $iteration["hp"] += $value;
-                break;
-            case RUNE_STAT_ID::SPD:
-                $iteration["speed"] += $value;
-                break;
-            case RUNE_STAT_ID::CRR:
-                $iteration["crit_rate"] += $value;
-                break;
-            case RUNE_STAT_ID::CRD:
-                $iteration["crit_damage"] += $value;
-                break;
-            case RUNE_STAT_ID::ACC:
-                $iteration["accuracy"] += $value;
-                break;
-            case RUNE_STAT_ID::RES:
-                $iteration["resistance"] += $value;
-                break;
-            case RUNE_STAT_ID::ATK_P:
-                $iteration["attack"] += ($base_atk * $value / 100);
-                break;
-            case RUNE_STAT_ID::DEF_P:
-                $iteration["defense"] += ($base_def * $value / 100);
-                break;
-            case RUNE_STAT_ID::HP_P:
-                $iteration["hp"] += ($base_hp * $value / 100);
-                break;
-        }
-    }
-    
-    /**
-     * Function to sort arrays based on the "increment" key.
-     *
-     * @param $a An array
-     * @param $b Other array
-     * @return int Positive if $b before $a, negative otherwise. 
-     */
-    function sortOptions($a, $b) {
-        return $b["variation"] - $a["variation"];
-    }
-?>

application/action/optimize_get_options.php

@@ -44,11 +44,14 @@
             return -2;
         }
         $unit = new Unit($unit_id, true, $uid);
-        error_log("ATK" . $unit->attack);
+
+        $tuning = filter_input(INPUT_POST, 'tuning');
+        if ($tuning == null){
+            return -1;
+        }
 
         $options = json_decode(filter_input(INPUT_POST, 'options'), true);
         if ($options == null){
-            error_log("NO JSON");
             return -2;
         }
         foreach ($options as $option){
@@ -75,6 +78,7 @@
                 ];
                 
                 // Calculate stat increment
+                // TODO: Main stat at level!
                 $stat_ids = [
                     $rune->main_stat,
                     $rune->innate_stat,
@@ -83,6 +87,27 @@
                     $rune->substat_3,
                     $rune->substat_4
                 ];
+                $main_value = $rune->main_stat_value;
+                switch ($tuning){
+                    case 1: // All +12
+                        if ($rune->level < 12){
+                            $main_value = $rune->get_main_stat_at_level(12);
+                        }
+                        break;
+                    case 2: // Even +15, Odd + 12
+                        if ($rune->level < 15 && $rune->slot % 2 == 0){
+                            $main_value = $rune->get_main_stat_at_level(15);
+                        }
+                        elseif ($rune->level < 12 && $rune->slot % 2 != 0){
+                            $main_value = $rune->get_main_stat_at_level(12);
+                        }
+                        break;
+                    case 3: // All +15
+                        if ($rune->level < 15){
+                            $main_value = $rune->get_main_stat_at_level(15);
+                        }
+                        break;
+                }
                 $stat_values = [
                     $rune->main_stat_value,
                     $rune->innate_stat_value,
@@ -128,6 +153,8 @@
                             break;
                     }
                 }
+
+                // Calculate EHP and DMG
                 $set["stats"]["ehp"] = ceil(((($set["stats"]["def"] * 3.5) + 1140) * $set["stats"]["hp"]) / 1000);
                 $atk = $set["stats"]["attack"];
                 $crr = $set["stats"]["crit_rate"];
@@ -137,12 +164,15 @@
                 $crd = $set["stats"]["crit_damage"];
                 $edmg = ceil(($atk * (100 - $crr) / 100) + (($atk + ($atk * $crd / 100)) * $crr / 100));
                 $set["stats"]["dmg"] = $edmg;
-                // TODO calculte ehp, dmg
+
+                // Add to the array
                 array_push($set["runes"], $r);
                 
             }
             array_push($runes, $set);
         }
+
+        // Send back the response
         $response = json_encode($runes);
         if ($response == null){
             return 0;

application/action/optimize_get_rune_list.php

@@ -187,7 +187,6 @@
 
         $total_candidates = 0;
         for ($i = 1; $i <= 6; $i ++){
-        error_log($s[$i]);
             $q = $db->query($s[$i]);
             while ($r = $q->fetchArray(SQLITE3_ASSOC)){
                 $rune = create_rune_array($unit, $r, $tuning);
@@ -243,7 +242,7 @@
                     $main_value = get_main_stat_at_level(15, $r["main_stat"], $r["stars"]);
                 }
                 elseif ($level < 12 && $r["slot"] % 2 != 0){
-                    $main_value = get_main_stat_at_level(15, $r["main_stat"], $r["stars"]);
+                    $main_value = get_main_stat_at_level(12, $r["main_stat"], $r["stars"]);
                 }
                 break;
             case 3: // All +15

application/view/optimizer_unit.php

@@ -96,6 +96,25 @@
              * To calculate time.
              */
             var timestamp = 0;
+            
+            /**
+             * Enables or disables a new search.
+             *
+             * When disabled, the apply button will be disabled and a waiting
+             * icon will be shown.
+             *
+             * @param enable true to enable, false to disable.
+             */
+            function enableNewSearch(enable){
+                if (enable === true){
+                    document.getElementById('apply').removeAttribute('disabled');
+                    document.getElementById('wait').style.display = 'none';
+                }
+                else{
+                    document.getElementById('apply').setAttribute('disabled', 'disabled');
+                    document.getElementById('wait').style.display = 'block';
+                }
+            }
 
             /**
              * Updates the value next to the sliders when they change.
@@ -137,6 +156,22 @@
                 document.getElementById('min_' + stat).value = document.getElementById('min_' + stat).min;
             }
 
+            function log(text){
+                var log_window = document.getElementById('log_window');
+                var span = document.createElement('span');
+                span.setAttribute('class', 'log_message');
+                text = document.createTextNode(text);
+                span.appendChild(text);
+                log_window.appendChild(span);
+                log_window.scrollTo(0, 2 * log_window.offsetHeight);
+            }
+            function clearLog(){
+                const elements = document.querySelectorAll('.log_message');
+                Array.from(elements).forEach((element, index) => {
+                    element.remove(); 
+                });
+            }
+            
             /**
              * Starts the optimization.
              *
@@ -147,6 +182,7 @@
              * @return false on error, true on success.
              */
             function apply(){
+                log("Start optimization...");
 
                 var params = '';
                 var x;
@@ -241,18 +277,16 @@
                 var xhttp = new XMLHttpRequest();
                 xhttp.onreadystatechange = function() {
                     if (this.readyState == 4){
-                        document.getElementById('apply').removeAttribute('disabled');
-                        document.getElementById('wait').style.display = 'none';
-                        //console.log(this.response);
                         if (this.status == 200) {
                             time = ((+ new Date()) - timestamp) / 1000;
-                            showOptimizations(this.response, time);
-                        }
-                        else if (this.status == 413) { // Payload too large
-                            showMessage('Error', 'Too many combination found. Plesase narow your criteria and retry.');
+                            calculateOptimizations(this.response, time);
                         }
-                        else if (this.status == 500) { // Server error
-                            showMessage('Error', 'Too many rune combination found. Plesase narow your criteria and retry.');
+                        else{
+                            enableNewSearch(true);
+                            var time = ((+ new Date()) - timestamp) / 1000;
+                            log('Error ' + this.status + '(' + time + 's)');
+                            
+                            showMessage('Error', 'Unexpected error ' + this.status);
                         }
                     }
                 };
@@ -266,8 +300,7 @@
                 while (container.firstChild) {
                     container.removeChild(container.firstChild);
                 }
-                document.getElementById('apply').setAttribute('disabled', 'disabled');
-                document.getElementById('wait').style.display = 'block';
+                enableNewSearch(false);
                 document.getElementById('results').style.display = 'none';
 
                 // Start timer
@@ -279,20 +312,18 @@
                 xhttp.send(params);
             }
 
+            /**
+             * Checks if a rune combination is a valid set. To do so, checks:
+             *
+             * - That the sets are valid
+             * - That the sets are the same as requested
+             * - That it complies with the filters min values.
+             *
+             * @param candidates Array of 6 runes
+             * @return true if the set matches the criteria, false otherwise.
+             */
             function valid_set(candidates){
-            
-                // Debug section: Look out for current runes
-                if (
-                    candidates[0].ID == '18127229790' //&&
-                    //candidates[1].ID == '16037693193' &&
-                    //candidates[2].ID == '18831259497' &&
-                    //candidates[3].ID == '19634059762' &&
-                    //candidates[4].ID == '19057400217' &&
-                    //candidates[5].ID == '20095751566'
-                ){
-                    console.log("CURRENT SET!!");
-                }
-            
+
                 // Number of applied sets with the current candidates.
                 var sets = {
                     'RUNE_SET_<?=RUNE_SET_ID::ENERGY?>': 0, // ENERGY
@@ -320,7 +351,9 @@
                 for (var i = 0; i <= 5; i ++){
                     sets['RUNE_SET_' + candidates[i].TYPE] ++;
                 }
-                for (var i = 0; i < sets.length; i ++){
+                // TEST I think i dont need to check for valid sets, only that
+                // they match the requested sets.
+                /*for (var i = 0; i < sets.length; i ++){
                     switch (i){
                         case <?=RUNE_SET_ID::ENERGY?>:
                         case <?=RUNE_SET_ID::GUARD?>:
@@ -353,7 +386,7 @@
                             }
                             break;
                     }
-                }
+                }*/
                 
                 // Its a valid set, but does it match the requested sets?
                 var requested_sets = {
@@ -417,12 +450,10 @@
                     }
                 }
 
-                //console.log("VALID SET!");
                 if (JSON.stringify(sets) !== JSON.stringify(requested_sets)){
                     return false;
                 }
-                //console.log("VALID REQUESTED SET!");
-                
+
                 // Compare with filters
                 var new_stats = {
                     "ATK": base_stats["attack"],
@@ -448,7 +479,6 @@
                 }
                 new_stats["EHP"] = Math.ceil((((new_stats["DEF"] * 3.5) + 1140) * new_stats["HP"]) / 1000);
                 new_stats["DMG"] = Math.ceil((new_stats["ATK"] * (100 - new_stats["CRR"]) / 100) + ((new_stats["ATK"] + (new_stats["ATK"] * new_stats["CRD"] / 100)) * new_stats["CRR"] / 100));
-                //console.log("HP " + new_stats["HP"] + "/" + document.getElementById('min_hp').value);
                 if (
                     new_stats["ATK"] >= document.getElementById('min_attack').value &&
                     new_stats["DEF"] >= document.getElementById('min_defense').value &&
@@ -461,22 +491,22 @@
                     new_stats["EHP"] >= document.getElementById('min_ehp').value &&
                     new_stats["DMG"] >= document.getElementById('min_dmg').value
                 ){
-                    //console.log("IMPROVING SET!");
-                    return true
+                    return true;
                 }
                 return false;
             }
-            
+
             /**
-             * Parses the received content and creates the HTML with the new
-             * rune options.
+             * Parses the received runes and looks for valid candidates.
+             * Once it's done, it calls the server agai to get rune info.
              *
              * @param content JSON received from server.
              */
-            function showOptimizations(content, time){
+            async function calculateOptimizations(content, time){
                 var container = document.getElementById('optimizations');
                 var data = JSON.parse(content);
-                //console.log(data);
+
+                // Create a 0-index array grouped by slot
                 var candidates = [
                     data[1],
                     data[2],
@@ -485,37 +515,29 @@
                     data[5],
                     data[6]
                 ];
+
+                // Calculate total combinations.
+                var total_runes = data[1].length +  data[2].length +  data[3].length +  data[4].length +  data[5].length +  data[6].length;
                 var total_combinations = data[1].length *  data[2].length *  data[3].length *  data[4].length *  data[5].length *  data[6].length;
+                if (total_combinations == 0){
+                    var time = ((+ new Date()) - timestamp) / 1000;
+                    log('No rune combinations found (' + time + 's)');
+                    showMessage('No results', 'No runes found matching your criteria.');
+                }
+                var time = ((+ new Date()) - timestamp) / 1000;
+                log(total_runes + ' runes found (' + total_combinations + ' combinations) (' + time + 's)');
+                // TODO Prevent user on high numbers
                 var checked_combinations = 0;
-                // Valic combinations that match the minimum requeriments
+                
+                // Valid combinations that match the minimum requeriments
                 var valid_combinations = [];
-                console.log("TOTAL COMBINATIONS: " + total_combinations);
-                // TODO Prevent user on high numbers
+
                 // Counters to keep track on array indexes
                 var counters = [0, 0, 0, 0, 0, 0];
-                
-                
+                // Loop all posible combinations. When a valid set is found,
+                // add it to valid_combinations
                 while (true){
-                
-                    // Check loop exit condition
-                    if (
-                        counters[0] >= candidates[0].length &&
-                        counters[1] >= candidates[1].length &&
-                        counters[2] >= candidates[2].length &&
-                        counters[3] >= candidates[3].length &&
-                        counters[4] >= candidates[4].length &&
-                        counters[5] >= candidates[5].length
-                    ){
-                        console.log("BREAK BY condition");
-                        break;
-                    }
-                    
-                    // TODO DEBUG Exit a 3
-                    if (checked_combinations >= 3000000){
-                        console.log("BREAK BY hard limit");
-                        break;
-                    }
-                
+
                     if (valid_set([
                       candidates[0][counters[0]],
                       candidates[1][counters[1]],
@@ -536,7 +558,7 @@
                             ]
                         });
                     }
-                    
+
                     // Increase counters
                     checked_combinations ++;
                     counters[5] ++;
@@ -561,7 +583,6 @@
                         counters[0] ++;
                     }
                     if (counters[0] >= candidates[0].length){
-                        console.log("BREAK BY increments");
                         break;
                     }
                     
@@ -574,11 +595,15 @@
                         console.log("  4:  " + counters[4] + "/" + candidates[4].length);
                         console.log("  5:  " + counters[5] + "/" + candidates[5].length);
                     }*/
-                    
-                    
-                    
                 }
-                
+
+                // If no valid combinations: exit now
+                if (valid_combinations.length == 0){
+                    enableNewSearch(true);
+                    var time = ((+ new Date()) - timestamp) / 1000;
+                    log('No suitable combination found (' + time + 's).');
+                    showMessage('No results', 'No suitable combination found. Plesase relax your criteria and retry.');
+                }
                 // Foreach valid combination, rate it and sort the array
                 for (var i = 0; i < valid_combinations.length; i ++){
                     for (var r = 0; r < 6; r ++){
@@ -592,66 +617,54 @@
                         valid_combinations[i]['score'] += (valid_combinations[i]["runes"][r]["ATK"] * 1.2);
                     }
                 }
-                console.log("CHECKED: " + checked_combinations + "/" + total_combinations);
+                var time = ((+ new Date()) - timestamp) / 1000;
+                log(valid_combinations.length + ' suitable combinations found (' + time + 's)');
                 valid_combinations.sort(function(a, b) {return b['score'] - a['score'];});
-                valid_combinations = valid_combinations.slice(0, document.getElementById('limit').value);
-                console.log("SIZE: " + valid_combinations.length);
-//                 for (var i = 0; i < valid_combinations.length; i ++){
-//                     console.log(valid_combinations[i]['score']);
-//                 }
-                
+                if (valid_combinations.length > document.getElementById('limit').value){
+                    var time = ((+ new Date()) - timestamp) / 1000;
+                    log('Selecting the ' + document.getElementById('limit').value + ' best combinations (' + time + 's)');
+                    valid_combinations = valid_combinations.slice(0, document.getElementById('limit').value);
+                }
+
                 // Request to fetch the runes.
-                // TODO
-                // Make the request
                 var xhttp = new XMLHttpRequest();
                 xhttp.onreadystatechange = function() {
                     if (this.readyState == 4){
-                        console.log("RUNES RECEIVED");
-                        console.log(this.response);
                         if (this.status == 200) {
                             //time = ((+ new Date()) - timestamp) / 1000;
-                            presentOptions(this.response, time);
+                            presentOptions(this.response, timestamp);
                         }
-                        /*document.getElementById('apply').removeAttribute('disabled');
-                        document.getElementById('wait').style.display = 'none';
-                        //console.log(this.response);
-                        if (this.status == 200) {
-                            time = ((+ new Date()) - timestamp) / 1000;
-                            showOptimizations(this.response, time);
-                        }
-                        else if (this.status == 413) { // Payload too large
-                            showMessage('Error', 'Too many combination found. Plesase narow your criteria and retry.');
+                        else{
+                            enableNewSearch(true);
+                            showMessage('Error', 'Unexpected error ' + this.status);
                         }
-                        else if (this.status == 500) { // Server error
-                            showMessage('Error', 'Too many rune combination found. Plesase narow your criteria and retry.');
-                        }*/
                     }
                 };
-                params = 'uid=<?=$UID?>&unit=<?=$page->unit->id?>';
+                params = 'uid=<?=$UID?>&unit=<?=$page->unit->id?>&tuning=' + document.getElementById('tuning').options[document.getElementById('tuning').selectedIndex].value;
                 params += '&options=' + JSON.stringify(valid_combinations);
                 xhttp.open('POST', '/action/optimize_get_options/', true);
                 xhttp.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');
                 xhttp.send(params);
-                // Send the request
-                
-                
-                
                 return;
-                
-                
             }
-            function presentOptions(content, time){
+
+            /**
+             * Displays the options.
+             *
+             * Builds a table with the calculated options and their scores.
+             * If none. It will show a message. In any case, it reenables the search
+             * button
+             *
+             * @param content Response from /action/optimize_get_options/
+             * @param timestamp Time counter
+             */
+            function presentOptions(content, timestamp){
                 var container = document.getElementById('optimizations');
                 var data = JSON.parse(content);
-                
-                
-                if (Number(data.total) == 0){
-                    showMessage('No results', 'No suitable combination found. Plesase relax your criteria and retry.');
+                if (data.length == 0){
+                    enableNewSearch(true);
                     return;
                 }
-                document.getElementById('num_results').innerHTML = data.total;
-                document.getElementById('num_skipped').innerHTML = data.skipped;
-                document.getElementById('num_seconds').innerHTML = time;
                 var option;
                 var tr;
                 var td;
@@ -1041,8 +1054,18 @@
                     document.getElementById('results').style.display = 'block';
 
                 }
+                time = ((+ new Date()) - timestamp) / 1000;
+                log('Done in ' + time + ' seconds');
+                enableNewSearch(true);
             }
             
+            /**
+             * Function to sort rune combinations based on their score.
+             *
+             * @param a One combination.
+             * @param b Other combination.
+             * @return Numeric index for sorting.
+             */
             function sortOptions(a, b) {
                 return b["score"] - a["score"];
             }
@@ -1066,6 +1089,11 @@
                 document.getElementById('message_container').style.display = 'none';
             }
             
+            /**
+             * DEBUG FUNCTION
+             *
+             * Sets filters to a known value for debugging.
+             */
             function debug(){
                 document.getElementById('set_1').selectedIndex = 0;
                 document.getElementById('set_2').selectedIndex = 0;
@@ -1081,7 +1109,6 @@
                 removeFilter('dmg');
                 document.getElementById('lbl_min_hp').value = 13500;
                 updateMinValue('hp', document.getElementById('lbl_min_hp'));
-                //apply();
             }
         </script>
     </head>
@@ -1396,7 +1423,6 @@
                     //foreach ($page->unit->rune as $rune){
                     foreach ($show_list as $i){
                         $rune = $page->unit->rune[$i - 1];
-                        $total_runes ++;
 ?>
                         <?=HTML::rune_table($rune)?>
 <?php
@@ -1603,9 +1629,15 @@
                             </td>
                         </tr>
                         <tr>
-                            <td class='empty'>
-                            </td>
-                            <td class='empty'>
+                            <td id='log' colspan='2' rowspan='4'>
+                                <div id='log_title'>
+                                    LOG
+                                    <span id='log_clear' onClick='clearLog();'>
+                                        clear
+                                    </span>
+                                </div>
+                                <div id='log_window'>
+                                </div>
                             </td>
                             <td class='empty'>
                             </td>
@@ -1624,10 +1656,10 @@
                             </td>
                         </tr>
                         <tr>
-                            <td class='empty'>
-                            </td>
-                            <td class='empty'>
-                            </td>
+                            <!--<td class='empty'>
+                            </td>-->
+                            <!--<td class='empty'>
+                            </td>-->
                             <td class='empty'>
                             </td>
                             <td class='name'>
@@ -1645,10 +1677,10 @@
                             </td>
                         </tr>
                         <tr>
-                            <td class='empty'>
-                            </td>
-                            <td class='empty'>
-                            </td>
+                            <!--<td class='empty'>
+                            </td>-->
+                            <!--<td class='empty'>
+                            </td>-->
                             <td class='empty'>
                             </td>
                             <td class='name'>
@@ -1666,10 +1698,10 @@
                             </td>
                         </tr>
                         <tr>
-                            <td class='empty'>
-                            </td>
-                            <td class='empty'>
-                            </td>
+                            <!--<td class='empty'>
+                            </td>-->
+                            <!--<td class='empty'>
+                            </td>-->
                             <td class='empty'>
                             </td>
                             <td class='name'>
@@ -1689,7 +1721,7 @@
                         <tr>
                             <td class='action'>
                                 <input id='apply' type='button' value='Apply' onClick='apply();'/>
-                                <input id='apply' type='button' value='DEBUG' onClick='debug();'/>
+                                <!--<input id='apply' type='button' value='DEBUG' onClick='debug();'/>-->
                             </td>
                             <td class='empty'>
                                 <img id='wait' src='<?=URL::IMG["ICON"] . "wait.gif";?>'>
@@ -1710,10 +1742,6 @@
                                 </a>
                             </td>
                         </tr>
-
-
-
-
                     </table>
                 </article>
             </section>
@@ -1722,9 +1750,6 @@
                     Optimization results
                 </h2>
                 <article>
-                    <div id='results_info'>
-                        <span id='num_results'></span> results (<span id='num_skipped'></span> skipped) in <span id='num_seconds'></span> seconds
-                    </div>
                     <table id='table_optimizations'>
                         <tbody id='optimizations'>
                         </tbody>

public/css/optimizer.css

@@ -223,7 +223,40 @@ section#parameters article img#wait{
     height: 2.5em;
     display: none;
 }
-
+section#parameters td#log{
+    border: 0.1em solid #000000;
+    border-radius: 0.3em;
+    vertical-align: bottom;
+    overflow-y: scroll;
+    position: relative;
+    background-color: #000000;
+}
+section#parameters td#log div#log_title{
+    position: absolute;
+    font-weight: bold;
+    color: #ffffff;
+    top: 0;
+    left: 0;
+    right: 0;
+    border-bottom: 0.1em solid #ffffff;
+    background-color: #000000;
+}
+section#parameters td#log div#log_title span#log_clear{
+    float: right;
+    cursor: pointer;
+    font-size: 90%;
+}
+section#parameters td#log div#log_window{
+    height: 6.5em;
+    overflow-y: scroll;
+    scrollbar-width: thin;
+}
+section#parameters td#log div#log_window span.log_message{
+    font-family: monospace;
+    display: block;
+    margin: 0 0 0 0.5em;
+    font-size: 90%;
+}
 section#results{
     display: none;
 }
@@ -293,6 +326,8 @@ section#results td.runes table.rune{
 section#results table#table_optimizations{
     border-collapse: collapse;
     margin: auto;
+    border-left: 0.1em solid #000000cc;
+    border-right: 0.1em solid #000000cc;
 }
 
 section#results td.option_stats, section#results td.runes{