SWDB/application/action/optimize_get_rune_list.php

<?php
/**
 * File for the rune optimization action.
 *
 * Implements an action function to be called from the {@see Controller}.
 *
 * @author Iñigo Valentin <i@inigovalentin.com>
 * @license https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License V3
 * @package SWDB
 */

/**
 * Selects the runes for optimization.
 *
 * Reads the POST parameters looking for the following KEYS:
 *  player: Player ID.
 *  mode: Game mode ({@see GAME_MODE_ID}).
 *  unit: Unit ID.
 *  source: Source of the runes to select (assigned, unassigned, ...).
 *  tuning: 1: All +12; 2: Even +15, odd + 12; 3: All +15.
 *  set[]: Selected rune sets ({@see RUNE_SET_ID}).
 *  
 * Then it selects all the runes matching the cryteria.
 * 
 * @return int|string a JSON with the runes on success, negative integers on error. 0 if no errors
 * ocurred, but no results were found.
 * @category Action
 */
function action(){

    // Increase max execution time.
    set_time_limit(60);

    $candidates = [
        1 => [],
        2 => [],
        3 => [],
        4 => [],
        5 => [],
        6 => []
    ];

    $response = null;

    $player = filter_input(INPUT_POST, 'player');
    if ($player == null){
        return -1;
    }
    $game_mode = GAME_MODE_ID::NORMAL;
    if (filter_input(INPUT_POST, 'mode') == GAME_MODE_ID::RTA){
        $game_mode = GAME_MODE_ID::RTA;
    }

    $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;
    }

    $tuning = filter_input(INPUT_POST, 'tuning');
    if ($tuning == null){
        return -6;
    }

    // Instantiate the unit
    $unit = new Unit($unit_id);

    // Get build query:
    $base_s = "
      SELECT
        id,
        type,
        slot,
        level,
        stars,
        (SELECT stat FROM rune_stat WHERE rune = rune.id AND slot = " . RUNE_STAT_SLOT_ID::MAIN . " ) AS main_stat,
        (SELECT value FROM rune_stat WHERE rune = rune.id AND slot = " . RUNE_STAT_SLOT_ID::MAIN . " ) AS main_stat_value,
        (SELECT stat FROM rune_stat WHERE rune = rune.id AND slot = " . RUNE_STAT_SLOT_ID::INNATE . " ) AS innate_stat,
        (SELECT value FROM rune_stat WHERE rune = rune.id AND slot = " . RUNE_STAT_SLOT_ID::INNATE . " ) AS innate_stat_value,
        (SELECT stat FROM rune_stat WHERE rune = rune.id AND slot = " . RUNE_STAT_SLOT_ID::SUBSTAT_1 . " ) AS substat_1,
        (SELECT value + grind FROM rune_stat WHERE rune = rune.id AND slot = " . RUNE_STAT_SLOT_ID::SUBSTAT_1 . " ) AS substat_1_value,
        (SELECT stat FROM rune_stat WHERE rune = rune.id AND slot = " . RUNE_STAT_SLOT_ID::SUBSTAT_2 . " ) AS substat_2,
        (SELECT value + grind FROM rune_stat WHERE rune = rune.id AND slot = " . RUNE_STAT_SLOT_ID::SUBSTAT_2 . " ) AS substat_2_value,
        (SELECT stat FROM rune_stat WHERE rune = rune.id AND slot = " . RUNE_STAT_SLOT_ID::SUBSTAT_3 . " ) AS substat_3,
        (SELECT value + grind FROM rune_stat WHERE rune = rune.id AND slot = " . RUNE_STAT_SLOT_ID::SUBSTAT_3 . " ) AS substat_3_value,
        (SELECT stat FROM rune_stat WHERE rune = rune.id AND slot = " . RUNE_STAT_SLOT_ID::SUBSTAT_4 . " ) AS substat_4,
        (SELECT value + grind FROM rune_stat WHERE rune = rune.id AND slot = " . RUNE_STAT_SLOT_ID::SUBSTAT_4 . " ) AS substat_4_value
      FROM rune
      WHERE
        player = :player AND
        type IN (
    ";
    foreach ($sets as $set){
        $base_s .= ($set . ",");
    }
    $base_s .= "-1) AND ";
    switch ($source){
        case 0: // Storage only (or itself)
            $base_s .= "
              (
                rune.id IN (SELECT DISTINCT unit FROM unit_rune WHERE unit = :unit_id AND rta = " . $game_mode . ")
                OR rune.id NOT IN (SELECT DISTINCT unit FROM unit_rune WHERE rta = " . $game_mode . ")
              )";
            break;
        case 1: // Units in no teams (or itself)
            $base_s .= "
              (
                rune.id IN (SELECT DISTINCT unit FROM unit_rune WHERE unit = :unit_id AND rta = " . $game_mode . ")
                OR rune.id NOT IN (SELECT DISTINCT unit FROM unit_rune WHERE rta = " . $game_mode . ")
                OR rune.id NOT IN (SELECT DISTINCT unit FROM unit_rune WHERE rta = " . $game_mode . " AND unit NOT IN (SELECT DISTINCT unit FROM team_unit))
              )
            ";
            break;
        case 2: // Units in teams with 0 score (or itself)
            $base_s .= "
              (
                rune.id IN (SELECT DISTINCT unit FROM unit_rune WHERE unit = :unit_id AND rta = " . $game_mode . ")
                OR rune.id NOT IN (SELECT DISTINCT unit FROM unit_rune WHERE rta = " . $game_mode . ")
                OR rune.id NOT IN (
                  SELECT DISTINCT unit 
                  FROM unit_rune 
                  WHERE
                    rta = " . $game_mode . "
                    AND unit 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_in = " main_stat IN (:stat_0, :stat_1, :stat_2) ";

    $s = ["", "", "", "", "", "", ""];
    $s[1] = $base_s . " AND slot = 1 " . $s_order;
    $s[3] = $base_s . " AND slot = 3 " . $s_order;
    $s[5] = $base_s . " AND slot = 5 " . $s_order;
    $s[2] = $base_s . " AND slot = 2 AND " . $s_in . $s_order;
    $s[4] = $base_s . " AND slot = 4 AND " . $s_in . $s_order;
    $s[6] = $base_s . " AND slot = 6 AND " . $s_in . $s_order;

    $total_candidates = 0;
    for ($i = 1; $i <= 6; $i ++){
        //error_log($s[$i]);
        $statement = get_context()->get_db()->prepare($s[$i]);
        $statement->bindValue(':player', $player, SQLITE3_TEXT);
        $statement->bindValue(':unit_id', $unit_id, SQLITE3_TEXT);
        $statement->bindValue(':stat_0', $stats[0], SQLITE3_TEXT);
        $statement->bindValue(':stat_1', $stats[1], SQLITE3_TEXT);
        $statement->bindValue(':stat_2', $stats[2], SQLITE3_TEXT);
        $q = $statement->execute();
        while ($r = $q->fetchArray(SQLITE3_ASSOC)){
            $rune = create_rune_array($unit, $r, $tuning);
            //array_push($candidates[$i], new Rune($r["id"]));
            array_push($candidates[$i], $rune);
            $total_candidates ++;
        }
    }
    //$max_combinations = sizeof($candidates[1]) * sizeof($candidates[2]) * sizeof($candidates[3]) * sizeof($candidates[4]) * sizeof($candidates[5]) * sizeof($candidates[6]);

    // Build response
    $response = json_encode($candidates);
    if ($response == null){
        return 0;
    }
    else{
        return $response;
    }
}

/**
 * Creates an array with the stats provided by a rune on a unit.
 *
 * @param Unit $unit Target unit.
 * @param int $r Rune main stat ID.
 * @param int $stars Rune stars.
      * @return int Value of the main stat at the selected level.
 */
function create_rune_array($unit, $r, $tuning){
    $rune = [
        "ID" => $r["id"],
        "TYPE" => $r["type"],
        "ATK" => 0,
        "DEF" => 0,
        "HP" => 0,
        "SPD" => 0,
        "CRR" => 0,
        "CRD" => 0,
        "ACC" => 0,
        "RES" => 0
    ];
    // Calculate main stat value based on requested level.
    $level = $r["level"];
    $main_value = $r["main_stat_value"];
    switch ($tuning){
        case 1: // All +12
            if ($level < 12){
                $main_value = get_main_stat_at_level(12, $r["main_stat"], $r["stars"]);
            }
            break;
        case 2: // Even +15, Odd + 12
            if ($level < 15 && $r["slot"] % 2 == 0){
                $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(12, $r["main_stat"], $r["stars"]);
            }
            break;
        case 3: // All +15
            if ($level < 15){
                $main_value = get_main_stat_at_level(15, $r["main_stat"], $r["stars"]);
            }
            break;
    }
    // Array to loop.
    $stats = [
        [
            "STAT" => $r["main_stat"],
            "VALUE" => $main_value
        ],
        [
            "STAT" => $r["innate_stat"],
            "VALUE" => $r["innate_stat_value"]
        ],
        [
            "STAT" => $r["substat_1"],
            "VALUE" => $r["substat_1_value"]
        ],
        [
            "STAT" => $r["substat_2"],
            "VALUE" => $r["substat_2_value"]
        ],
        [
            "STAT" => $r["substat_3"],
            "VALUE" => $r["substat_3_value"]
        ],
        [
            "STAT" => $r["substat_4"],
            "VALUE" => $r["substat_4_value"]
        ]
    ];
    foreach ($stats as $stat){
        switch ($stat["STAT"]){
            case RUNE_STAT_ID::ATK:
                $rune["ATK"] += $stat["VALUE"];
                break;
            case RUNE_STAT_ID::ATK_P:
                $rune["ATK"] += ($unit->get_base_stats()["atk"] * $stat["VALUE"] / 100);
                break;
            case RUNE_STAT_ID::DEF:
                $rune["DEF"] += $stat["VALUE"];
                break;
            case RUNE_STAT_ID::DEF_P:
                $rune["DEF"] += ($unit->get_base_stats()["def"] * $stat["VALUE"] / 100);
                break;
            case RUNE_STAT_ID::HP:
                $rune["HP"] += $stat["VALUE"];
                break;
            case RUNE_STAT_ID::HP_P:
                $rune["HP"] += ($unit->get_base_stats()["hp"] * $stat["VALUE"] / 100);
                break;
            case RUNE_STAT_ID::SPD:
                $rune["SPD"] += $stat["VALUE"];
                break;
            case RUNE_STAT_ID::CRR:
                $rune["CRR"] += $stat["VALUE"];
                break;
            case RUNE_STAT_ID::CRD:
                $rune["CRD"] += $stat["VALUE"];
                break;
            case RUNE_STAT_ID::ACC:
                $rune["ACC"] += $stat["VALUE"];
                break;
            case RUNE_STAT_ID::RES:
                $rune["RES"] += $stat["VALUE"];
                break;
        }
    }
    return $rune;
}

/**
 * Gets the value of the main stat at an arbitrary level.
 *
 * @param int $level Desired level.
 * @param int $stat Rune main stat ID.
 * @param int $stars Rune stars.
      * @return int Value of the main stat at the selected level.
 */
function get_main_stat_at_level($level, $stat, $stars){
    $level = intval($level);
    if ($level < 0 || $level > 15){
        return 0;
    }
    switch ($stat){
        case RUNE_STAT_ID::HP:
            return RUNE_STAT_VALUES::HP[$stars][$level];
        case RUNE_STAT_ID::HP_P:
            return RUNE_STAT_VALUES::HP_P[$stars][$level];
        case RUNE_STAT_ID::ATK:
            return RUNE_STAT_VALUES::ATK[$stars][$level];
        case RUNE_STAT_ID::ATK_P:
            return RUNE_STAT_VALUES::ATK_P[$stars][$level];
        case RUNE_STAT_ID::DEF:
            return RUNE_STAT_VALUES::DEF[$stars][$level];
        case RUNE_STAT_ID::DEF_P:
            return RUNE_STAT_VALUES::DEF_P[$stars][$level];
        case RUNE_STAT_ID::SPD:
            return RUNE_STAT_VALUES::SPD[$stars][$level];
        case RUNE_STAT_ID::CRR:
            return RUNE_STAT_VALUES::CRR[$stars][$level];
        case RUNE_STAT_ID::CRD:
            return RUNE_STAT_VALUES::CRD[$stars][$level];
        case RUNE_STAT_ID::RES:
            return RUNE_STAT_VALUES::RES[$stars][$level];
        case RUNE_STAT_ID::ACC:
            return RUNE_STAT_VALUES::ACC[$stars][$level];
        default:
            return 0;
    }
}