InventoryTransaction.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\event\inventory\InventoryTransactionEvent;
use pocketmine\inventory\Inventory;
use pocketmine\inventory\transaction\action\InventoryAction;
use pocketmine\inventory\transaction\action\SlotChangeAction;
use pocketmine\item\Item;
use pocketmine\player\Player;
use pocketmine\utils\Utils;
use function array_keys;
use function array_values;
use function assert;
use function count;
use function get_class;
use function min;
use function shuffle;
use function spl_object_hash;
use function spl_object_id;
 
class InventoryTransaction{
    protected bool $hasExecuted = false;
 
    protected array $inventories = [];
 
    protected array $actions = [];
 
    public function __construct(
        protected Player $source,
        array $actions = []
    ){
        foreach($actions as $action){
            $this->addAction($action);
        }
    }
 
    public function getSource() : Player{
        return $this->source;
    }
 
    public function getInventories() : array{
        return $this->inventories;
    }
 
    public function getActions() : array{
        return $this->actions;
    }
 
    public function addAction(InventoryAction $action) : void{
        if(!isset($this->actions[$hash = spl_object_id($action)])){
            $this->actions[$hash] = $action;
            $action->onAddToTransaction($this);
            if($action instanceof SlotChangeAction && !isset($this->inventories[$inventoryId = spl_object_id($action->getInventory())])){
                $this->inventories[$inventoryId] = $action->getInventory();
            }
        }else{
            throw new \InvalidArgumentException("Tried to add the same action to a transaction twice");
        }
    }
 
    private function shuffleActions() : void{
        $keys = array_keys($this->actions);
        shuffle($keys);
        $actions = [];
        foreach($keys as $key){
            $actions[$key] = $this->actions[$key];
        }
        $this->actions = $actions;
    }
 
    protected function matchItems(array &$needItems, array &$haveItems) : void{
        $needItems = [];
        $haveItems = [];
        foreach($this->actions as $key => $action){
            if(!$action->getTargetItem()->isNull()){
                $needItems[] = $action->getTargetItem();
            }
 
            try{
                $action->validate($this->source);
            }catch(TransactionValidationException $e){
                throw new TransactionValidationException(get_class($action) . "#" . spl_object_id($action) . ": " . $e->getMessage(), 0, $e);
            }
 
            if(!$action->getSourceItem()->isNull()){
                $haveItems[] = $action->getSourceItem();
            }
        }
 
        foreach($needItems as $i => $needItem){
            foreach($haveItems as $j => $haveItem){
                if($needItem->canStackWith($haveItem)){
                    $amount = min($needItem->getCount(), $haveItem->getCount());
                    $needItem->setCount($needItem->getCount() - $amount);
                    $haveItem->setCount($haveItem->getCount() - $amount);
                    if($haveItem->getCount() === 0){
                        unset($haveItems[$j]);
                    }
                    if($needItem->getCount() === 0){
                        unset($needItems[$i]);
                        break;
                    }
                }
            }
        }
        $needItems = array_values($needItems);
        $haveItems = array_values($haveItems);
    }
 
    protected function squashDuplicateSlotChanges() : void{
        $slotChanges = [];
        $inventories = [];
        $slots = [];
 
        foreach($this->actions as $key => $action){
            if($action instanceof SlotChangeAction){
                $slotChanges[$h = (spl_object_hash($action->getInventory()) . "@" . $action->getSlot())][] = $action;
                $inventories[$h] = $action->getInventory();
                $slots[$h] = $action->getSlot();
            }
        }
 
        foreach(Utils::stringifyKeys($slotChanges) as $hash => $list){
            if(count($list) === 1){ //No need to compact slot changes if there is only one on this slot
                continue;
            }
 
            $inventory = $inventories[$hash];
            $slot = $slots[$hash];
            if(!$inventory->slotExists($slot)){ //this can get hit for crafting tables because the validation happens after this compaction
                throw new TransactionValidationException("Slot $slot does not exist in inventory " . get_class($inventory));
            }
            $sourceItem = $inventory->getItem($slot);
 
            $targetItem = $this->findResultItem($sourceItem, $list);
            if($targetItem === null){
                throw new TransactionValidationException("Failed to compact " . count($list) . " duplicate actions");
            }
 
            foreach($list as $action){
                unset($this->actions[spl_object_id($action)]);
            }
 
            if(!$targetItem->equalsExact($sourceItem)){
                //sometimes we get actions on the crafting grid whose source and target items are the same, so dump them
                $this->addAction(new SlotChangeAction($inventory, $slot, $sourceItem, $targetItem));
            }
        }
    }
 
    protected function findResultItem(Item $needOrigin, array $possibleActions) : ?Item{
        assert(count($possibleActions) > 0);
 
        $candidate = null;
        $newList = $possibleActions;
        foreach($possibleActions as $i => $action){
            if($action->getSourceItem()->equalsExact($needOrigin)){
                if($candidate !== null){
                    /*
                     * we found multiple possible actions that match the origin action
                     * this means that there are multiple ways that this chain could play out
                     * if we cared so much about this, we could build all the possible chains in parallel and see which
                     * variation managed to complete the chain, but this has an extremely high complexity which is not
                     * worth the trouble for this scenario (we don't usually expect to see chains longer than a couple
                     * of actions in here anyway), and might still result in multiple possible results.
                     */
                    return null;
                }
                $candidate = $action;
                unset($newList[$i]);
            }
        }
        if($candidate === null){
            //chaining is not possible with this origin, none of the actions are valid
            return null;
        }
 
        if(count($newList) === 0){
            return $candidate->getTargetItem();
        }
        return $this->findResultItem($candidate->getTargetItem(), $newList);
    }
 
    public function validate() : void{
        $this->squashDuplicateSlotChanges();
 
        $haveItems = [];
        $needItems = [];
        $this->matchItems($needItems, $haveItems);
        if(count($this->actions) === 0){
            throw new TransactionValidationException("Inventory transaction must have at least one action to be executable");
        }
 
        if(count($haveItems) > 0){
            throw new TransactionValidationException("Transaction does not balance (tried to destroy some items)");
        }
        if(count($needItems) > 0){
            throw new TransactionValidationException("Transaction does not balance (tried to create some items)");
        }
    }
 
    protected function callExecuteEvent() : bool{
        $ev = new InventoryTransactionEvent($this);
        $ev->call();
        return !$ev->isCancelled();
    }
 
    public function execute() : void{
        if($this->hasExecuted()){
            throw new TransactionValidationException("Transaction has already been executed");
        }
 
        $this->shuffleActions();
 
        $this->validate();
 
        if(!$this->callExecuteEvent()){
            throw new TransactionCancelledException("Transaction event cancelled");
        }
 
        foreach($this->actions as $action){
            if(!$action->onPreExecute($this->source)){
                throw new TransactionCancelledException("One of the actions in this transaction was cancelled");
            }
        }
 
        foreach($this->actions as $action){
            $action->execute($this->source);
        }
 
        $this->hasExecuted = true;
    }
 
    public function hasExecuted() : bool{
        return $this->hasExecuted;
    }
}