minecraft-kajetans-mod/src/main/java/me/km/snuviscript/ScriptEvents.java

package me.km.snuviscript;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.UUID;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import me.hammerle.snuviscript.code.Compiler;
import me.hammerle.snuviscript.code.Script;
import me.hammerle.snuviscript.code.SnuviParser;
import me.hammerle.snuviscript.math.Fraction;
import me.kcm.events.PlayerPreRespawnEvent;
import me.km.KajetansMod;
import me.km.api.ModuleListener;
import me.km.api.Module;
import me.km.api.Utils;
import me.km.dimensions.ModDimensions;
import me.km.effects.PlayerUsesEffectEvent;
import me.km.entities.EntityHuman;
import me.km.entities.EntityItemProjectile;
import me.km.events.PlayerHurtEvent;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.passive.EntitySheep;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.init.Items;
import net.minecraft.inventory.ClickType;
import net.minecraft.item.ItemStack;
import net.minecraft.server.management.PlayerList;
import net.minecraft.util.EnumHand;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.RayTraceResult;
import net.minecraftforge.event.CommandEvent;
import net.minecraftforge.event.entity.EntityMountEvent;
import net.minecraftforge.event.entity.ThrowableImpactEvent;
import net.minecraftforge.event.entity.item.ItemTossEvent;
import net.minecraftforge.event.entity.living.*;
import net.minecraftforge.event.entity.player.EntityItemPickupEvent;
import net.minecraftforge.event.entity.player.FillBucketEvent;
import net.minecraftforge.event.entity.player.ItemFishedEvent;
import net.minecraftforge.event.entity.player.PlayerDropsEvent;
import net.minecraftforge.event.entity.player.PlayerInteractEvent;
import net.minecraftforge.event.world.BlockEvent;
import net.minecraftforge.fml.common.eventhandler.Event;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import net.minecraftforge.fml.common.gameevent.PlayerEvent;
import net.minecraftforge.fml.common.gameevent.PlayerEvent.PlayerRespawnEvent;

public class ScriptEvents extends ModuleListener
{               
    private final HashMap<UUID, UUID> questJoin;
    private final SnuviParser parser;
                 
    public ScriptEvents(Module m)
    {    
        super(m);
        questJoin = new HashMap<>();
        parser = KajetansMod.scripts.getSnuviParser();
    }  
    
    // -------------------------------------------------------------------------
    // basics
    // -------------------------------------------------------------------------
    
    private void handleEvent(EntityPlayer p, String event, Consumer<Script> before, Consumer<Script> after)
    {      
        parser.callEvent(event, (sc) -> 
        {
            if(p != null)
            {
                ScriptVars.setPlayerVars(sc, p); 
            }
            before.accept(sc);
        }, after);
        
        if(p != null)
        {
            Script data = KajetansMod.scripts.getScript(p);
            if(data != null)
            {
                parser.callEvent(event, data, (sc) -> 
                {
                    ScriptVars.setPlayerVars(sc, p); 
                    before.accept(sc);
                }, after);
            }
        }      
    }

    private void handleEvent(EntityPlayer p, String event, Consumer<Script> before)
    {      
        handleEvent(p, event, before, null);
    }
    
    private void simpleCancel(Script sc, Event e, String name)
    {
        try
        {
            e.setCanceled(sc.getVar("cancel").getBoolean(sc)); 
        }
        catch(Exception ex)
        {
            KajetansMod.scripts.logger.print("invalid var in '" + name + "' event", ex, null, sc.getName(), sc, sc.getActiveRealLine());
        }
    }
         
    // -------------------------------------------------------------------------
    // events
    // -------------------------------------------------------------------------

    public void onPlayerMove(EntityPlayer p)
    {      
        handleEvent(p, "player_move", null);
    }
    
    public boolean onInventoryClick(Script script, SnuviInventory inv, int slot, ClickType click, EntityPlayer p)
    {
        parser.callEvent("inv_click", script, sc -> 
        {
            ScriptVars.setPlayerVars(sc, p); 
            sc.setVar("inv_id", new Fraction(inv.getId()));
            sc.setVar("inv_name", inv.getName());
            sc.setVar("inv_slot", new Fraction(slot));
            ScriptVars.setItemVars(sc, inv.getStackInSlot(slot));
            sc.setVar("cancel", false); 
        }, null);
        return script.getVar("cancel").getBoolean(script);
    }

    public void onInventoryClose(Script script, SnuviInventory inv, EntityPlayer p)
    {
        parser.callEvent("inv_close", script, sc -> 
        {
            ScriptVars.setPlayerVars(sc, p); 
            sc.setVar("inv_id", new Fraction(inv.getId()));
            sc.setVar("inv_name", inv.getName());
        }, null);
    }
    
    public void onHumanHurt(EntityPlayer p, EntityHuman h)
    {
        handleEvent(p, "human_hurt", sc -> ScriptVars.setEntityVars(sc, h));
    }
    
    @SubscribeEvent
    public void onPlayerPostRespawn(PlayerRespawnEvent e)
    {
        handleEvent(e.player, "player_post_respawn", null);
    }
    
    @SubscribeEvent
    public void onPlayerPreRespawn(PlayerPreRespawnEvent e)
    {
        handleEvent(e.getEntityPlayer(), "player_pre_respawn", null);
    }
    
    @SubscribeEvent
    public void onPlayerDamage(PlayerHurtEvent e)
    {        
        EntityPlayer p = e.getEntityPlayer();  
        handleEvent(p, "player_hurt", (sc) -> 
        {
            if(p.getHealth() <= e.getAmount())
            {
                sc.setVar("player_killed", true);   
            }  
            else
            {
                sc.setVar("player_killed", false); 
            }
            sc.setVar("player_damage", Fraction.fromDouble(e.getAmount()));   
            sc.setVar("player_damage_cause", e.getSource().getDamageType());
            EntityPlayer ent = Utils.getDamager(e.getSource());
            if(ent != null)
            {
                sc.setVar("player_involved", true);
                ScriptVars.setSecPlayer(sc, ent);
            }
            else
            {
                sc.setVar("player_involved", false);
            }
            sc.setVar("cancel", e.isCanceled()); 
        }, (sc) -> 
        {
            try
            {
                e.setAmount(sc.getVar("player_damage").getFraction(sc).floatValue());
                e.setCanceled(sc.getVar("cancel").getBoolean(sc)); 
            }
            catch(Exception ex)
            {
                KajetansMod.scripts.logger.print("invalid var in 'player_hurt' event", ex, null, sc.getName(), sc, sc.getActiveRealLine());
            }
        });
    } 
    
    @SubscribeEvent
    public void onPlayerDamage(LivingHealEvent e)
    {        
        if(e.getEntityLiving() instanceof EntityPlayer)
        {
            handleEvent((EntityPlayer) e.getEntityLiving(), "player_heal", (sc) -> 
            {
                sc.setVar("heal", Fraction.fromDouble(e.getAmount()));
                sc.setVar("cancel", e.isCanceled()); 
            }, (sc) -> 
            {
                try
                {
                    e.setAmount(sc.getVar("heal").getFraction(sc).floatValue());
                    e.setCanceled(sc.getVar("cancel").getBoolean(sc)); 
                }
                catch(Exception ex)
                {
                    KajetansMod.scripts.logger.print("invalid var in 'player_heal' event", ex, null, sc.getName(), sc, sc.getActiveRealLine());
                }
            });
        }
    } 
    
    @SubscribeEvent
    public void onLivingDeath(LivingDeathEvent e)
    {        
        if(!(e.getEntityLiving() instanceof EntityPlayer))
        {
            handleEvent(null, "entity_death", (sc) -> 
            {
                EntityLivingBase ent = e.getEntityLiving();
                ScriptVars.setEntityVars(sc, ent);
                EntityPlayer p = Utils.getDamager(e.getSource());
                if(p != null)
                {
                    sc.setVar("player_involved", true);
                    ScriptVars.setPlayerVars(sc, p);
                }  
                else
                {
                    sc.setVar("player_involved", false);
                }
                sc.setVar("cancel", e.isCanceled()); 
            }, (sc) -> 
            {
                simpleCancel(sc, e, "entity_death");
            });
            return;
        }
        EntityPlayer p = (EntityPlayer) e.getEntity();    
        handleEvent(p, "player_death", (sc) -> 
        {
            sc.setVar("clear", false);
            EntityPlayer ent = Utils.getDamager(e.getSource());
            if(ent != null)
            {
                ScriptVars.setSecPlayer(sc, ent);
            }
            sc.setVar("cancel", e.isCanceled()); 
        }, (sc) -> 
        {
            try
            {
                if(sc.getVar("clear").getBoolean(sc))
                {
                    p.inventory.clear();
                }
                e.setCanceled(sc.getVar("cancel").getBoolean(sc)); 
            }
            catch(Exception ex)
            {
                KajetansMod.scripts.logger.print("invalid var in 'player_death' event", ex, null, sc.getName(), sc, sc.getActiveRealLine());
            }
        });
    } 
       
    @SubscribeEvent
    public void onEntityDamage(LivingHurtEvent e)
    {        
        EntityPlayer p = Utils.getDamager(e.getSource());
        if(p == null)
        {
            return;
        }
        handleEvent(p, "entity_hurt", (sc) -> 
        {
            sc.setVar("entity_killed", e.getEntityLiving().getHealth() <= e.getAmount());        
            ScriptVars.setEntityVars(sc, e.getEntity()); 
            sc.setVar("entity_damage", Fraction.fromDouble(e.getAmount()));   
            sc.setVar("entity_damage_cause", e.getSource().getDamageType());
            sc.setVar("cancel", e.isCanceled());   
        }, (sc) -> 
        {
            try
            {
                e.setAmount(sc.getVar("entity_damage").getFraction(sc).floatValue());
                e.setCanceled(sc.getVar("cancel").getBoolean(sc)); 
            }
            catch(Exception ex)
            {
                KajetansMod.scripts.logger.print("invalid var in 'entity_hurt' event", ex, null, sc.getName(), sc, sc.getActiveRealLine());
            }
        });
    }
    
    @SubscribeEvent
    public void onEntityDrop(LivingDropsEvent e)
    {             
        try
        {
            handleEvent(null, "entity_drop", (sc) -> 
            {
                sc.setVar("drops", e.getDrops());
                ScriptVars.setEntityVars(sc, e.getEntityLiving());
                EntityPlayer p = Utils.getDamager(e.getSource());
                if(p != null)
                {
                    sc.setVar("player_involved", true);
                    ScriptVars.setPlayerVars(sc, p);
                }  
                else
                {
                    sc.setVar("player_involved", false);
                }
                sc.setVar("cancel", e.isCanceled()); 
            }, (sc) -> 
            {
                simpleCancel(sc, e, "entity_drop");
            });
        }
        catch(NullPointerException ex)
        {
            KajetansMod.scripts.sendWarningToConsole(ex.toString() + "  " + ex.getMessage());
        }
    } 
            
    @SubscribeEvent
    public void onPlayerDrop(PlayerDropsEvent e)
    {             
        handleEvent(e.getEntityPlayer(), "player_drop", (sc) -> 
        {
            sc.setVar("cancel", e.isCanceled()); 
        }, (sc) -> 
        {
            simpleCancel(sc, e, "player_drop");
        });
    } 
    
    @SubscribeEvent
    public void onProjectileHit(ThrowableImpactEvent e)
    {        
        EntityPlayer p = Utils.getPlayerFromProjectile(e.getEntityThrowable());
        if(p != null)
        {
            handleEvent(p, "throw_hit", (sc) -> 
            {
                if(e.getRayTraceResult().entityHit != null)
                {
                    sc.setVar("is_entity_hit", true);
                    sc.setVar("entity_hit", e.getRayTraceResult().entityHit);
                }
                else
                {
                    sc.setVar("is_entity_hit", false);
                }
                ScriptVars.setEntityVars(sc, e.getEntityThrowable());
            });
        }           
    }
    
    public void onEntityItemProjectileHit(EntityItemProjectile ent, EntityPlayer p, ItemStack stack, List<Entity> ents)
    {        
        handleEvent(p, "item_hit", (sc) -> 
        {
            ScriptVars.setEntityVars(sc, ent);
            ScriptVars.setItemVars(sc, stack);
            sc.setVar("entities", ents);
        });      
    }
    
    @SubscribeEvent
    public void onEntityShear(PlayerInteractEvent.EntityInteract e)
    {              
        if(e.getHand() == EnumHand.OFF_HAND || !(e.getTarget() instanceof EntitySheep))
        {
            return;
        }
        EntityPlayer p = e.getEntityPlayer();   
        if(p.getHeldItemMainhand().getItem() != Items.SHEARS)
        {
            return;
        }
        EntitySheep sheep = (EntitySheep) e.getTarget();
        handleEvent(p, "entity_shear", (sc) -> 
        {
            ScriptVars.setEntityVars(sc, sheep);
            sc.setVar("entity_sheared", sheep.getSheared());
            sc.setVar("entity_color", sheep.getFleeceColor().toString());
            sc.setVar("cancel", e.isCanceled()); 
        }, (sc) -> 
        {
            try
            {
                sheep.setSheared(sc.getVar("entity_sheared").getBoolean(sc));
                e.setCanceled(sc.getVar("cancel").getBoolean(sc)); 
            }
            catch(Exception ex)
            {
                KajetansMod.scripts.logger.print("invalid var in 'entity_shear' event", ex, null, sc.getName(), sc, sc.getActiveRealLine());
            }
        });
    }
       
    @SubscribeEvent
    public void onBlockBreak(BlockEvent.BreakEvent e)
    {        
        handleEvent(e.getPlayer(), "block_break", (sc) -> 
        {
            ScriptVars.setBlockVars(sc, e.getWorld(), e.getPos());
            sc.setVar("cancel", e.isCanceled()); 
        }, (sc) -> 
        {
            simpleCancel(sc, e, "block_break");
        });
    }
    
    @SubscribeEvent
    public void onPlayerLogin(PlayerEvent.PlayerLoggedInEvent e)
    {    
        EntityPlayer p = e.player;
        if(p == null)
        {
            return;
        }
        handleEvent(p, "player_login", (sc) -> 
        {       
            sc.setVar("first_join", Utils.hasPlayedBefore(p));
            PlayerList list = KajetansMod.server.getPlayerList();
            sc.setVar("is_banned", list.getBannedPlayers().isBanned(p.getGameProfile()));
            sc.setVar("is_whitelisted", list.getWhitelistedPlayers().isWhitelisted(p.getGameProfile()));
        });
    }
    
    @SubscribeEvent
    public void onPlayerLogout(PlayerEvent.PlayerLoggedOutEvent e)
    {    
        EntityPlayer p = e.player;
        if(p == null)
        {
            return;
        }
        handleEvent(p, "player_logout", null);
    }
    
    @SubscribeEvent
    public void onBucketFill(FillBucketEvent e)
    {      
        handleEvent(e.getEntityPlayer(), "bucket_fill", (sc) -> 
        {
            RayTraceResult ray = e.getTarget();
            if(ray != null)
            {
                BlockPos pos = ray.getBlockPos();
                if(pos != null)
                {
                    sc.setVar("has_block", true); 
                    ScriptVars.setBlockVars(sc, e.getWorld(), pos);
                }
                else
                {
                    sc.setVar("has_block", false); 
                }
            }
            else
            {
                sc.setVar("has_block", false); 
            }
            sc.setVar("cancel", e.isCanceled()); 
        }, (sc) -> 
        {
            simpleCancel(sc, e, "bucket_fill");
        });
    } 
       
    @SubscribeEvent
    public void onBlockPlace(BlockEvent.PlaceEvent e)
    {
        handleEvent(e.getPlayer(), "block_place", (sc) -> 
        {
            sc.setVar("block_type_after", e.getPlacedBlock().getBlock().getRegistryName());
            ScriptVars.setBlockVars(sc, e.getWorld(), e.getPos());
            sc.setVar("cancel", e.isCanceled()); 
        }, (sc) -> 
        {
            simpleCancel(sc, e, "block_place");
        });
    }    
    
    @SubscribeEvent
    public void onRightClickBlock(PlayerInteractEvent.RightClickBlock e)
    {
        if(e.getHand() == EnumHand.OFF_HAND)
        {
            return;
        }
        handleEvent(e.getEntityPlayer(), "block_click", (sc) -> 
        {
            sc.setVar("action", "right");
            ScriptVars.setBlockVars(sc, e.getWorld(), e.getPos());
            sc.setVar("cancel", e.isCanceled()); 
        }, (sc) -> 
        {
            simpleCancel(sc, e, "block_click");
        });       
    }
    
    @SubscribeEvent
    public void onLeftClickBlock(PlayerInteractEvent.LeftClickBlock e)
    {
        if(e.getHand() == EnumHand.OFF_HAND)
        {
            return;
        }
        handleEvent(e.getEntityPlayer(), "block_click", (sc) -> 
        {
            sc.setVar("action", "left");
            ScriptVars.setBlockVars(sc, e.getWorld(), e.getPos());
            sc.setVar("cancel", e.isCanceled()); 
        }, (sc) -> 
        {
            simpleCancel(sc, e, "block_click");
        });       
    }
    
    @SubscribeEvent(receiveCanceled = true)
    public void onEntityClick(PlayerInteractEvent.EntityInteract e)
    {
        if(e.getHand() != EnumHand.OFF_HAND)
        {
            handleEvent(e.getEntityPlayer(), "entity_click", (sc) -> 
            {
                ScriptVars.setEntityVars(sc, e.getTarget());
                sc.setVar("cancel", e.isCanceled()); 
            }, (sc) -> 
            {
                simpleCancel(sc, e, "entity_click");
            });
        }
    }
    
    @SubscribeEvent
    public void onFishing(ItemFishedEvent e)
    {
        handleEvent(e.getEntityPlayer(), "fishing", (sc) -> 
        {
            sc.setVar("drops", e.getDrops());
            sc.setVar("cancel", e.isCanceled()); 
        }, (sc) -> 
        {
            simpleCancel(sc, e, "fishing");
        });
    }
    
    @SubscribeEvent
    public void onItemClick(PlayerInteractEvent.RightClickItem e)
    {        
        handleEvent(e.getEntityPlayer(), "item_air_click", (sc) -> 
        {
            ScriptVars.setItemVars(sc, e.getItemStack());
            sc.setVar("hand", e.getHand().toString());
            sc.setVar("cancel", e.isCanceled());  
        }, (sc) -> 
        {
            simpleCancel(sc, e, "item_air_click");
        });
    }
    
    public void onArmSwing(EntityPlayer p, EnumHand hand)
    {        
        handleEvent(p, "arm_swing", (sc) -> 
        {
            sc.setVar("hand", hand);
        });
    }
    
    @SubscribeEvent
    public void onItemUseStart(LivingEntityUseItemEvent.Start e)
    {        
        if(!(e.getEntityLiving() instanceof EntityPlayer))
        {
            return;
        }
        handleEvent((EntityPlayer) e.getEntityLiving(), "item_use_start", (sc) -> 
        {
            sc.setVar("duration", new Fraction(e.getDuration()));
            sc.setVar("cancel", e.isCanceled());  
        }, (sc) -> 
        {
            try
            {
                e.setDuration(sc.getVar("duration").getInt(sc));
                e.setCanceled(sc.getVar("cancel").getBoolean(sc)); 
            }
            catch(Exception ex)
            {
                KajetansMod.scripts.logger.print("invalid var in 'item_use_start' event", ex, null, sc.getName(), sc, sc.getActiveRealLine());
            }
        });
    }
    
    @SubscribeEvent
    public void onConsuming(LivingEntityUseItemEvent.Finish e)
    {
        if(!(e.getEntityLiving() instanceof EntityPlayer))
        {
            return;
        }
        handleEvent((EntityPlayer) e.getEntityLiving(), "item_use_finish", (sc) -> 
        {
            sc.setVar("result_stack", e.getResultStack());  
        });
    }
    
    @SubscribeEvent
    public void onCrafting(PlayerEvent.ItemCraftedEvent e)
    {  
        handleEvent(e.player, "craft", (sc) -> 
        {
            ScriptVars.setItemVars(sc, e.crafting);
        });   
    } 
    
    @SubscribeEvent
    public void onItemDrop(ItemTossEvent e)
    {
        handleEvent(e.getPlayer(), "player_toss", (sc) -> 
        {
            ScriptVars.setItemVars(sc, e.getEntityItem().getItem());   
            sc.setVar("cancel", e.isCanceled()); 
        }, (sc) -> 
        {
            simpleCancel(sc, e, "player_toss");
        });
    }
    
    @SubscribeEvent
    public void onItemPickup(EntityItemPickupEvent e)
    {
        handleEvent(e.getEntityPlayer(), "player_pickup", (sc) -> 
        {
            ScriptVars.setEntityVars(sc, e.getItem()); 
            ScriptVars.setItemVars(sc, e.getItem().getItem());  
            sc.setVar("cancel", e.isCanceled()); 
        }, (sc) -> 
        {
            simpleCancel(sc, e, "player_pickup");
        });
    }
    
    @SubscribeEvent
    public void onVehicleEnter(EntityMountEvent e)
    {
        if(!(e.getEntityMounting() instanceof EntityPlayer))
        {
            return;
        }
        EntityPlayer p = (EntityPlayer) e.getEntityMounting();
        handleEvent(p, "entity_mount", (sc) -> 
        {
            sc.setVar("mounting", e.isMounting()); 
            ScriptVars.setEntityVars(sc, e.getEntityBeingMounted()); 
            sc.setVar("cancel", e.isCanceled()); 
        }, (sc) -> 
        {
            simpleCancel(sc, e, "entity_mount");
        });
    }
    
    @SubscribeEvent
    public void onPlayerUsePortal(PlayerEvent.PlayerChangedDimensionEvent e)
    {
        handleEvent(e.player, "portal", (sc) -> 
        {
            sc.setVar("from", ModDimensions.getWorldName(e.fromDim));
            sc.setVar("to", ModDimensions.getWorldName(e.toDim));
        });
    }
    
    @SubscribeEvent
    public void onCommand(CommandEvent e)
    {
        if(e.getSender() instanceof EntityPlayer)
        {
            handleEvent((EntityPlayer) e.getSender(), "command", (sc) -> 
            {
                sc.setVar("command", e.getCommand().getName()); 
                sc.setVar("args", Arrays.stream(e.getParameters()).map(s -> Compiler.convert(s)).collect(Collectors.toList()));
                sc.setVar("cancel", e.isCanceled()); 
            }, (sc) -> 
            {
                simpleCancel(sc, e, "command");
            });
        }
    }
    
    public void onCustomCommand(EntityPlayer p, String command, String[] args)
    {
        handleEvent(p, "custom_command", (sc) -> 
        {
            sc.setVar("command", command);
            if(args.length == 0)
            {
                sc.setVar("args", new ArrayList<>());
            }
            else
            {
                sc.setVar("args", Arrays.stream(args).map(s -> Compiler.convert(s)).collect(Collectors.toList()));
            }
        });
    }
      
    public void onEffectUse(PlayerUsesEffectEvent e)
    {    
        handleEvent(e.getPlayer(), "player_use_effect", (sc) -> 
        {       
            sc.setVar("power", new Fraction(e.getPower()));
            sc.setVar("mana_cost", new Fraction(e.getMana()));
            sc.setVar("cause", e.getCause().toString());
            sc.setVar("effect", e.getEffect());
            sc.setVar("cancel", e.isCanceled());
        }, (sc) -> 
        {
            try
            {
                e.setPower(Math.min(20, Math.max(1, sc.getVar("power").getInt(sc))));
                e.setMana(Math.max(0, sc.getVar("mana_cost").getInt(sc)));
                e.setCanceled(sc.getVar("cancel").getBoolean(sc)); 
            }
            catch(Exception ex)
            {
                KajetansMod.scripts.logger.print("invalid var in 'player_use_effect' event", ex, null, sc.getName(), sc, sc.getActiveRealLine());
            }
        });
    }
    
    public void onFunctionKey(EntityPlayerMP p, int key)
    {        
        handleEvent(p, "function_key", (sc) -> 
        {
            sc.setVar("key", new Fraction(key));
        });      
    }
}