EnergonRelics/src/main/java/com/thebrokenrail/energonrelics/api/energy/Action.java

package com.thebrokenrail.energonrelics.api.energy;

import net.minecraft.block.BlockState;
import net.minecraft.state.property.Property;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;

/**
 * Action That Can Be Performed With Energy
 */
public class Action {
    /**
     * Action Function
     */
    public interface ActionFunction {
        /**
         * Run Function
         * @param world World
         * @param pos Block Position
         * @param state Block State
         */
        void run(World world, BlockPos pos, BlockState state);
    }

    private final long cost;
    private final ActionFunction success;
    private final ActionFunction fail;

    /**
     * Create Action
     * @param cost Cost In Energon
     * @param success Success Function
     * @param fail Failure Function
     */
    public Action(long cost, ActionFunction success, ActionFunction fail) {
        this.cost = cost;
        this.success = success;
        this.fail = fail;
    }

    /**
     * Create Action That Changes Block State Property
     * @param cost Cost In Energon
     * @param property Block State Property
     * @param successValue Value To Set On Success
     * @param failureValue Value To Set On Failure
     * @param <T> Block State Property Type
     * @return New Action
     */
    public static <T extends Comparable<T>> Action createBlockStatePropertyAction(long cost, Property<T> property, T successValue, T failureValue) {
        return new Action(cost, (world, pos, state) -> {
            if (state.contains(property) && !state.get(property).equals(successValue)) {
                world.setBlockState(pos, state.with(property, successValue));
            }
        }, (world, pos, state) -> {
            if (state.contains(property) && !state.get(property).equals(failureValue)) {
                world.setBlockState(pos, state.with(property, failureValue));
            }
        });
    }

    /**
     * Action That Has Been Propagated
     */
    public interface PropagatedAction {
        /**
         * Propagated Actions Track The Amount Of Payments Expected So They Know When All Payments Have Been Processed And Can Execute A Fail State If Needed
         * This Method Expands The Amount Of Payments Expected
         * @param amount Amount To Expand By
         */
        void expandPayments(int amount);
        /**
         * Amount Required To Cause A Success State
         * @return Energy Amount
         */
        long amountOwed();
        /**
         * Pay Energy
         * @param amount Energy Amount
         */
        void pay(long amount);
    }

    /**
     * Simple Implementation Of A Propagated Action
     */
    public static class PropagatedActionImpl implements PropagatedAction {
        private final Action action;
        private final World world;
        private final BlockPos pos;
        private final BlockState state;
        private int expectedPayments = 1;
        private int payments = 0;
        private long amountPaid = 0;

        /**
         * Create Propagated Action
         * @param action Action
         * @param world World
         * @param pos Position
         * @param state Block State
         */
        public PropagatedActionImpl(Action action, World world, BlockPos pos, BlockState state) {
            this.action = action;
            this.world = world;
            this.pos = pos;
            this.state = state;
        }

        @Override
        public void expandPayments(int amount) {
            if (amount < 1) {
                throw new UnsupportedOperationException();
            }
            expectedPayments = expectedPayments - 1 + amount;
        }

        @Override
        public long amountOwed() {
            return action.cost - amountPaid;
        }

        @Override
        public void pay(long amount) {
            amountPaid = amountPaid + amount;
            payments++;
            if (state != null) {
                if (amountOwed() <= 0) {
                    action.success.run(world, pos, state);
                } else if (payments >= expectedPayments) {
                    action.fail.run(world, pos, state);
                }
            }
        }
    }
}