CraftingTransaction.php

<?php
 
/*
 *
 *  ____            _        _   __  __ _                  __  __ ____
 * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
 * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
 * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
 * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * @author PocketMine Team
 * @link http://www.pocketmine.net/
 *
 *
 */
 
declare(strict_types=1);
 
namespace pocketmine\inventory\transaction;
 
use pocketmine\crafting\CraftingManager;
use pocketmine\crafting\CraftingRecipe;
use pocketmine\crafting\RecipeIngredient;
use pocketmine\event\inventory\CraftItemEvent;
use pocketmine\item\Item;
use pocketmine\player\Player;
use pocketmine\utils\Utils;
use function array_fill_keys;
use function array_keys;
use function array_pop;
use function count;
use function intdiv;
use function min;
use function uasort;
 
class CraftingTransaction extends InventoryTransaction{
    protected ?CraftingRecipe $recipe = null;
    protected ?int $repetitions = null;
 
    protected array $inputs = [];
    protected array $outputs = [];
 
    private CraftingManager $craftingManager;
 
    public function __construct(Player $source, CraftingManager $craftingManager, array $actions = [], ?CraftingRecipe $recipe = null, ?int $repetitions = null){
        parent::__construct($source, $actions);
        $this->craftingManager = $craftingManager;
        $this->recipe = $recipe;
        $this->repetitions = $repetitions;
    }
 
    private static function packItems(array $providedItems) : array{
        $packedProvidedItems = [];
        while(count($providedItems) > 0){
            $item = array_pop($providedItems);
            foreach($providedItems as $k => $otherItem){
                if($item->canStackWith($otherItem)){
                    $item->setCount($item->getCount() + $otherItem->getCount());
                    unset($providedItems[$k]);
                }
            }
            $packedProvidedItems[] = $item;
        }
 
        return $packedProvidedItems;
    }
 
    public static function matchIngredients(array $providedItems, array $recipeIngredients, int $expectedIterations) : void{
        if(count($recipeIngredients) === 0){
            throw new TransactionValidationException("No recipe ingredients given");
        }
        if(count($providedItems) === 0){
            throw new TransactionValidationException("No transaction items given");
        }
 
        $packedProvidedItems = self::packItems(Utils::cloneObjectArray($providedItems));
        $packedProvidedItemMatches = array_fill_keys(array_keys($packedProvidedItems), 0);
 
        $recipeIngredientMatches = [];
 
        foreach($recipeIngredients as $ingredientIndex => $recipeIngredient){
            $acceptedItems = [];
            foreach($packedProvidedItems as $itemIndex => $packedItem){
                if($recipeIngredient->accepts($packedItem)){
                    $packedProvidedItemMatches[$itemIndex]++;
                    $acceptedItems[$itemIndex] = $itemIndex;
                }
            }
 
            if(count($acceptedItems) === 0){
                throw new TransactionValidationException("No provided items satisfy ingredient requirement $recipeIngredient");
            }
 
            $recipeIngredientMatches[$ingredientIndex] = $acceptedItems;
        }
 
        foreach($packedProvidedItemMatches as $itemIndex => $itemMatchCount){
            if($itemMatchCount === 0){
                $item = $packedProvidedItems[$itemIndex];
                throw new TransactionValidationException("Provided item $item is not accepted by any recipe ingredient");
            }
        }
 
        //Most picky ingredients first - avoid picky ingredient getting their items stolen by wildcard ingredients
        //TODO: this is still insufficient when multiple wildcard ingredients have overlaps, but we don't (yet) have to
        //worry about those.
        uasort($recipeIngredientMatches, fn(array $a, array $b) => count($a) <=> count($b));
 
        foreach($recipeIngredientMatches as $ingredientIndex => $acceptedItems){
            $needed = $expectedIterations;
 
            foreach($packedProvidedItems as $itemIndex => $item){
                if(!isset($acceptedItems[$itemIndex])){
                    continue;
                }
 
                $taken = min($needed, $item->getCount());
                $needed -= $taken;
                $item->setCount($item->getCount() - $taken);
 
                if($item->getCount() === 0){
                    unset($packedProvidedItems[$itemIndex]);
                }
 
                if($needed === 0){
                    //validation passed!
                    continue 2;
                }
            }
 
            $recipeIngredient = $recipeIngredients[$ingredientIndex];
            $actualIterations = $expectedIterations - $needed;
            throw new TransactionValidationException("Not enough items to satisfy recipe ingredient $recipeIngredient for $expectedIterations (only have enough items for $actualIterations iterations)");
        }
 
        if(count($packedProvidedItems) > 0){
            throw new TransactionValidationException("Not all provided items were used");
        }
    }
 
    protected function matchOutputs(array $txItems, array $recipeItems) : int{
        if(count($recipeItems) === 0){
            throw new TransactionValidationException("No recipe items given");
        }
        if(count($txItems) === 0){
            throw new TransactionValidationException("No transaction items given");
        }
 
        $iterations = 0;
        while(count($recipeItems) > 0){
            $recipeItem = array_pop($recipeItems);
            $needCount = $recipeItem->getCount();
            foreach($recipeItems as $i => $otherRecipeItem){
                if($otherRecipeItem->canStackWith($recipeItem)){ //make sure they have the same wildcards set
                    $needCount += $otherRecipeItem->getCount();
                    unset($recipeItems[$i]);
                }
            }
 
            $haveCount = 0;
            foreach($txItems as $j => $txItem){
                if($txItem->canStackWith($recipeItem)){
                    $haveCount += $txItem->getCount();
                    unset($txItems[$j]);
                }
            }
 
            if($haveCount % $needCount !== 0){
                //wrong count for this output, should divide exactly
                throw new TransactionValidationException("Expected an exact multiple of required $recipeItem (given: $haveCount, needed: $needCount)");
            }
 
            $multiplier = intdiv($haveCount, $needCount);
            if($multiplier < 1){
                throw new TransactionValidationException("Expected more than zero items matching $recipeItem (given: $haveCount, needed: $needCount)");
            }
            if($iterations === 0){
                $iterations = $multiplier;
            }elseif($multiplier !== $iterations){
                //wrong count for this output, should match previous outputs
                throw new TransactionValidationException("Expected $recipeItem x$iterations, but found x$multiplier");
            }
        }
 
        if(count($txItems) > 0){
            //all items should be destroyed in this process
            throw new TransactionValidationException("Expected 0 items left over, have " . count($txItems));
        }
 
        return $iterations;
    }
 
    private function validateRecipe(CraftingRecipe $recipe, ?int $expectedRepetitions) : int{
        //compute number of times recipe was crafted
        $repetitions = $this->matchOutputs($this->outputs, $recipe->getResultsFor($this->source->getCraftingGrid()));
        if($expectedRepetitions !== null && $repetitions !== $expectedRepetitions){
            throw new TransactionValidationException("Expected $expectedRepetitions repetitions, got $repetitions");
        }
        //assert that $repetitions x recipe ingredients should be consumed
        self::matchIngredients($this->inputs, $recipe->getIngredientList(), $repetitions);
 
        return $repetitions;
    }
 
    public function validate() : void{
        $this->squashDuplicateSlotChanges();
        if(count($this->actions) < 1){
            throw new TransactionValidationException("Transaction must have at least one action to be executable");
        }
 
        $this->matchItems($this->outputs, $this->inputs);
 
        if($this->recipe === null){
            $failed = 0;
            foreach($this->craftingManager->matchRecipeByOutputs($this->outputs) as $recipe){
                try{
                    //compute number of times recipe was crafted
                    $this->repetitions = $this->matchOutputs($this->outputs, $recipe->getResultsFor($this->source->getCraftingGrid()));
                    //assert that $repetitions x recipe ingredients should be consumed
                    self::matchIngredients($this->inputs, $recipe->getIngredientList(), $this->repetitions);
 
                    //Success!
                    $this->recipe = $recipe;
                    break;
                }catch(TransactionValidationException $e){
                    //failed
                    ++$failed;
                }
            }
 
            if($this->recipe === null){
                throw new TransactionValidationException("Unable to match a recipe to transaction (tried to match against $failed recipes)");
            }
        }else{
            $this->repetitions = $this->validateRecipe($this->recipe, $this->repetitions);
        }
    }
 
    protected function callExecuteEvent() : bool{
        $ev = new CraftItemEvent($this, $this->recipe, $this->repetitions, $this->inputs, $this->outputs);
        $ev->call();
        return !$ev->isCancelled();
    }
}