package script.space.combat;

import script.*;
import script.base_class.*;
import script.combat_engine.*;
import java.util.Arrays;
import java.util.Hashtable;
import java.util.Vector;
import script.base_script;

import script.library.space_combat;
import script.library.space_battlefield;
import script.library.space_crafting;
import script.library.pclib;
import script.library.space_utils;
import script.library.space_content;
import script.library.ship_ai;
import script.library.utils;
import script.library.space_transition;
import script.library.space_pilot_command;
import script.library.gcw;

public class combat_ship extends script.base_script
{
    public combat_ship()
    {
    }
    public static final float BROKEN_COMPONENT_DEFAULT_MASS = 50000f;
    public static final float SPACE_YACHT_COMPONENT_DEFAULT_MASS = 0f;
    public static final string_id SID_TARGET_DISABLED = new string_id("space/quest", "target_disabled2");
    public static final int DROID_VOCALIZE_REACT_CHANCE = 2;
    public static final int SHIP_DAMAGED_SKILLMOD_PENALTY_TIME = 10;
    public static final int SHIP_FIRED_SKILLMOD_PENALTY_TIME = 5;
    public static final float STUNNED_COMPONENT_LOOP_TIME = 5.0f;
    public static final String NO_DAMAGE_WARN = "clienteffect/cbt_friendlyfire_warn.cef";
    public int OnAttach(obj_id self) throws InterruptedException
    {
        int[] intSlots = getShipChassisSlots(self);
        for (int intI = 0; intI < intSlots[intI]; intI++)
        {
            setShipComponentEfficiencyGeneral(self, intSlots[intI], 1.0f);
            setShipComponentEfficiencyEnergy(self, intSlots[intI], 1.0f);
        }
        messageTo(self, "setupRotationalVelocity", null, 2, false);
        return SCRIPT_CONTINUE;
    }
    public int setupRotationalVelocity(obj_id self, dictionary params) throws InterruptedException
    {
        if (isShipSlotInstalled(self, space_crafting.ENGINE))
        {
            space_crafting.setupChassisDifferentiation(self);
        }
        else 
        {
        }
        return SCRIPT_CONTINUE;
    }
    public int OnLogin(obj_id self) throws InterruptedException
    {
        space_combat.clearDeathFlags(self);
        return SCRIPT_CONTINUE;
    }
    public int OnShipHitByLightning(obj_id self, int frontBack, float damage) throws InterruptedException
    {
        if (damage > 0.f)
        {
            notifyShipDamage(self, null, damage);
        }
        float fltRemainingDamage = space_combat.doShieldDamage(null, self, space_combat.SHIP, damage, frontBack);
        return SCRIPT_CONTINUE;
    }
    public int OnShipHitByEnvironment(obj_id self, int frontBack, float damage) throws InterruptedException
    {
        if (damage > 0.f)
        {
            notifyShipDamage(self, null, damage);
        }
        float fltRemainingDamage = space_combat.doShieldDamage(null, self, space_combat.SHIP, damage, frontBack);
        return SCRIPT_CONTINUE;
    }
    public int OnShipWasHit(obj_id self, obj_id objAttacker, int intWeaponIndex, boolean isMissile, int missileType, int intTargetedComponent, boolean fromPlayerAutoTurret, float hitLocationX_o, float hitLocationY_o, float hitLocationZ_o) throws InterruptedException
    {
        int intDisabledTime = getIntObjVar(self, "isDisabled");
        if (intDisabledTime > 0)
        {
            int intTime = getGameTime();
            if (intTime > intDisabledTime)
            {
                setObjVar(self, "isDisabled", 0);
            }
            else 
            {
                return SCRIPT_CONTINUE;
            }
        }
        int intWeaponSlot = intWeaponIndex + ship_chassis_slot_type.SCST_weapon_0;
        if (hasObjVar(self, "intInvincible"))
        {
            ship_ai.unitAddDamageTaken(self, objAttacker, 1.0f);
            return SCRIPT_CONTINUE;
        }
        boolean bossShip = false;
        if (hasObjVar(self, "bossType"))
        {
            bossShip = true;
        }
        if (space_utils.isPlayerControlledShip(objAttacker) && hasObjVar(self, "objMissionOwner"))
        {
            obj_id objOwner = getObjIdObjVar(self, "objMissionOwner");
            if (isIdValid(objOwner) && exists(objOwner))
            {
                boolean absorb = true;
                obj_id group_id = getGroupObject(objOwner);
                if (isIdValid(group_id))
                {
                    obj_id[] groupMembers = space_utils.getSpaceGroupMemberIds(group_id);
                    if (groupMembers != null)
                    {
                        for (int i = 0; i < groupMembers.length; i++)
                        {
                            if (objAttacker == space_transition.getContainingShip(groupMembers[i]))
                            {
                                absorb = false;
                                break;
                            }
                        }
                    }
                }
                if (space_transition.getContainingShip(objOwner) == objAttacker)
                {
                    absorb = false;
                }
                if (absorb)
                {
                    Vector gunners = space_utils.getGunnersInShip(objAttacker);
                    if (gunners == null || gunners.size() == 0)
                    {
                        playClientEffectObj(getPilotId(objAttacker), NO_DAMAGE_WARN, getPilotId(objAttacker), "");
                    }
                    else 
                    {
                        for (int i = 0; i < gunners.size(); i++)
                        {
                            playClientEffectObj(((obj_id)gunners.get(i)), NO_DAMAGE_WARN, ((obj_id)gunners.get(i)), "");
                        }
                    }
                    return SCRIPT_CONTINUE;
                }
            }
        }
        if (space_combat.hasDeathFlags(self))
        {
            return SCRIPT_CONTINUE;
        }
        if (hasObjVar(self, "intNoPlayerDamage") && space_utils.isPlayerControlledShip(objAttacker))
        {
            return SCRIPT_CONTINUE;
        }
        if (!isShipSlotTargetable(self, intTargetedComponent))
        {
            intTargetedComponent = space_combat.SHIP;
        }
        if (hasScript(self, "space.combat.combat_ship_capital"))
        {
            return SCRIPT_CONTINUE;
        }
        if (!pvpCanAttack(objAttacker, self))
        {
            return SCRIPT_CONTINUE;
        }
        pvpAttackPerformed(objAttacker, self);
        if (hasScript(self, "e3demo.spawner_nebulon") || (hasScript(self, "e3demo.nebulon_damaged")))
        {
            return SCRIPT_CONTINUE;
        }
        space_combat.checkAndPerformCombatTaunts(objAttacker, self, "fltAttackTauntChance", "hitYou", 0);
        space_combat.checkAndPerformCombatTaunts(self, objAttacker, "fltDefendTauntChance", "gotHit", 0);
        obj_id objPilot = getPilotId(objAttacker);
        transform attackerTransform_w = getTransform_o2w(objAttacker);
        transform defenderTransform_w = getTransform_o2w(self);
        vector hitDirection_o = defenderTransform_w.rotateTranslate_p2l(attackerTransform_w.getPosition_p());
        int intSide = 0;
        if (hitDirection_o.z < 0.f)
        {
            intSide = 1;
        }
        if (utils.checkConfigFlag("ScriptFlags", "e3Demo"))
        {
            if (space_utils.isPlayerControlledShip(self))
            {
                int intSlot = rand(1, 4);
                int intIntensity = rand(1, 100);
                space_combat.doInteriorDamageNotification(self, intSlot, 100, intIntensity);
                return SCRIPT_CONTINUE;
            }
        }
        float fltDamage = space_combat.getShipWeaponDamage(objAttacker, self, intWeaponSlot, isMissile);
        if (isIdValid(getPilotId(self)))
        {
            if (hasObjVar(getPilotId(self), "intCombatDebug"))
            {
                if (isMissile)
                {
                    sendSystemMessageTestingOnly(getPilotId(self), "MISSILED! for " + fltDamage + "from " + objAttacker + " missile type is " + missileType);
                }
            }
        }
        if (fltDamage > 0.f)
        {
            notifyShipDamage(self, objAttacker, fltDamage);
            ship_ai.unitAddDamageTaken(self, objAttacker, fltDamage);
        }
        if (space_utils.isPlayerControlledShip(self))
        {
            if (!utils.hasLocalVar(self, "cmd.wasDamagedSkillMod"))
            {
                int time = getGameTime();
                utils.setLocalVar(self, "cmd.wasDamagedSkillMod", SHIP_DAMAGED_SKILLMOD_PENALTY_TIME + time);
            }
        }
        float fltRemainingDamage = space_combat.doShieldDamage(objAttacker, self, intWeaponSlot, fltDamage, intSide);
        if (fltRemainingDamage > 0)
        {
            if (bossShip && !utils.hasScriptVar(self, "shieldDepleted"))
            {
                messageTo(self, "shieldDepleted", null, 0f, false);
            }
            fltRemainingDamage = space_combat.doArmorDamage(objAttacker, self, intWeaponSlot, fltRemainingDamage, intSide);
            if (fltRemainingDamage > 0)
            {
                if (bossShip && !utils.hasScriptVar(self, "armorDepleted"))
                {
                    messageTo(self, "armorDepleted", null, 0f, false);
                }
                fltRemainingDamage = space_combat.doComponentDamage(objAttacker, self, intWeaponSlot, intTargetedComponent, fltRemainingDamage, intSide);
                if (fltRemainingDamage > 0)
                {
                    if (rand(1, 10) < DROID_VOCALIZE_REACT_CHANCE)
                    {
                        if (space_utils.isPlayerControlledShip(self))
                        {
                            space_combat.flightDroidVocalize(self, 1);
                        }
                    }
                    fltRemainingDamage = space_combat.doChassisDamage(objAttacker, self, intWeaponSlot, fltRemainingDamage);
                    if (fltRemainingDamage > 0)
                    {
                        setShipCurrentChassisHitPoints(self, 0.0f);
                        obj_id objDefenderPilot = getPilotId(self);
                        if (!space_utils.isPlayerControlledShip(self))
                        {
                            if (space_utils.isPlayerControlledShip(objAttacker) || (hasObjVar(objAttacker, "commanderPlayer")))
                            {
                                if (utils.hasLocalVar(self, "space.give_rewards"))
                                {
                                    utils.setLocalVar(self, "space.give_rewards", 2);
                                }
                                else 
                                {
                                    utils.setLocalVar(self, "space.give_rewards", 1);
                                }
                                space_combat.checkAndPerformCombatTaunts(self, objAttacker, "fltDieTauntChance", "death", 0);
                                space_combat.targetDestroyed(self);
                                return SCRIPT_CONTINUE;
                            }
                            else 
                            {
                                space_combat.targetDestroyed(self);
                                return SCRIPT_CONTINUE;
                            }
                        }
                        else 
                        {
                            space_combat.setDeathFlags(self);
                            space_combat.sendDestructionNotification(self, objAttacker);
                            float fltIntensity = rand(0, 1.0f);
                            handleShipDestruction(self, fltIntensity);
                            if (space_utils.isPlayerControlledShip(objAttacker))
                            {
                                obj_id[] crew = space_utils.getAllPlayersInShip(objAttacker);
                                gcw.grantSpacePvpKillCredit(getPilotId(self), crew);
                                utils.setScriptVar(self, "intPVPKill", 1);
                            }
                            messageTo(self, "killSpacePlayer", null, 10.0f, true);
                            space_combat.doDeathCleanup(self);
                            CustomerServiceLog("space_death", "%TU " + self + " Has been killed by " + objAttacker, getOwner(objAttacker));
                            if (space_battlefield.isInBattlefield(self))
                            {
                                CustomerServiceLog("battlefield", "%TU " + self + " Has been killed by " + objAttacker, getOwner(objAttacker));
                            }
                        }
                    }
                }
                if (rand(1, 10) < DROID_VOCALIZE_REACT_CHANCE)
                {
                    if (space_utils.isPlayerControlledShip(self))
                    {
                        space_combat.flightDroidVocalize(self, 2);
                    }
                }
            }
        }
        return SCRIPT_CONTINUE;
    }
    public int killSpacePlayer(obj_id self, dictionary params) throws InterruptedException
    {
        Vector objPlayers = space_transition.getContainedPlayers(self, null);
        if (objPlayers != null)
        {
            for (int intI = 0; intI < objPlayers.size(); intI++)
            {
                space_combat.strikeBomberCleanup(((obj_id)objPlayers.get(intI)));
            }
        }
        space_combat.killSpacePlayer(self);
        space_combat.clearDeathFlags(self);
        return SCRIPT_CONTINUE;
    }
    public int OnSpaceUnitEnterCombat(obj_id self, obj_id objTarget) throws InterruptedException
    {
        setCondition(self, CONDITION_WINGS_OPENED);
        space_combat.checkAndPerformCombatTaunts(self, objTarget, "fltIntroTauntChance", "entercombat", 0);
        return SCRIPT_CONTINUE;
    }
    public int OnInitialize(obj_id self) throws InterruptedException
    {
        obj_id player = utils.getContainingPlayer(self);
        if (!hasObjVar(self, "ship_refire_fix"))
        {
            String ship_refire_table = "datatables/space_loot/ship_refire_fix/" + getClusterName() + "_ships.iff";
            String id = "" + self;
            LOG("shipcontents", "ship: " + id + " versioning weapons with " + ship_refire_table);
            dictionary refireDict = utils.dataTableGetRow(ship_refire_table, id);
            if (refireDict == null)
            {
                LOG("shipcontents", "Ship for refire fix not found for " + self + ".");
            }
            else 
            {
                setObjVar(self, "ship_refire_fix", refireDict.getInt("count"));
                LOG("shipcontents", "Ship for refire fix found for " + self + " with " + refireDict.getInt("count") + " charges.");
            }
        }
        setCondition(self, CONDITION_ON);
        String strChassisType = getShipChassisType(self);
        int[] intSlots = space_crafting.getShipInstalledSlots(self);
        for (int intI = 0; intI < intSlots.length; intI++)
        {
            int currentSlotComponentType = ship_chassis_slot_type.getComponentTypeForSlot(intSlots[intI]);
            if (currentSlotComponentType != ship_component_type.SCT_modification)
            {
                float currentComponentMass = getShipComponentMass(self, intSlots[intI]);
                if (strChassisType.equals("player_sorosuub_space_yacht"))
                {
                    if (currentComponentMass != 0)
                    {
                        setShipComponentMass(self, intSlots[intI], SPACE_YACHT_COMPONENT_DEFAULT_MASS);
                    }
                }
                else if (currentComponentMass == 0)
                {
                    setShipComponentMass(self, intSlots[intI], BROKEN_COMPONENT_DEFAULT_MASS);
                }
            }
            if (intSlots[intI] == space_crafting.ENGINE)
            {
                space_crafting.setupChassisDifferentiation(self);
            }
            space_combat.recalculateEfficiency(intSlots[intI], self);
            if (currentSlotComponentType == ship_component_type.SCT_weapon)
            {
                int flags = getShipComponentFlags(self, intSlots[intI]);
                boolean isBitSet = (flags & ship_component_flags.SCF_reverse_engineered) != 0;
                if (isBitSet)
                {
                    space_crafting.recalculateFireRateFromSlot(player, self, intSlots[intI]);
                }
            }
        }
        return SCRIPT_CONTINUE;
    }
    public int OnDestroy(obj_id self) throws InterruptedException
    {
        if (!isIdValid(self) || !exists(self))
        {
            return SCRIPT_CONTINUE;
        }
        obj_id[] notifylist = getObjIdArrayObjVar(self, "destroynotify");
        if (notifylist != null)
        {
            dictionary outparams = new dictionary();
            outparams.put("object", self);
            for (int i = 0; i < notifylist.length; i++)
            {
                if (exists(notifylist[i]) && (notifylist[i].isLoaded()))
                {
                    space_utils.notifyObject(notifylist[i], "shipDestroyed", outparams);
                }
            }
        }
        if (!space_utils.isPlayerControlledShip(self))
        {
            if (hasObjVar(self, "objParent"))
            {
                space_content.notifySpawner(self);
            }
        }
        if (utils.hasLocalVar(self, "space.give_rewards"))
        {
            if (utils.getIntLocalVar(self, "space.give_rewards") == 1)
            {
                space_combat.grantRewardsAndCreditForKills(self);
            }
        }
        return SCRIPT_CONTINUE;
    }
    public int objectDestroyed(obj_id self, dictionary params) throws InterruptedException
    {
        obj_id objPilot = getPilotId(self);
        if (!space_utils.isPlayerControlledShip(self))
        {
            if (hasObjVar(self, "objParent"))
            {
                space_content.notifySpawner(self);
            }
            float fltIntensity = rand(0, 1.0f);
            handleShipDestruction(self, fltIntensity);
        }
        else 
        {
            float fltIntensity = rand(0, 1.0f);
            handleShipDestruction(self, fltIntensity);
            return SCRIPT_CONTINUE;
        }
        return SCRIPT_CONTINUE;
    }
    public int targetDestroyed(obj_id self, dictionary params) throws InterruptedException
    {
        if (!space_utils.isPlayerControlledShip(self))
        {
            return SCRIPT_CONTINUE;
        }
        Vector objOfficers = space_utils.getShipOfficers(self);
        for (int intI = 0; intI < objOfficers.size(); intI++)
        {
            space_utils.notifyObject(((obj_id)objOfficers.get(intI)), "targetDestroyed", params);
        }
        return SCRIPT_CONTINUE;
    }
    public int targetDisabled(obj_id self, dictionary params) throws InterruptedException
    {
        obj_id objDefender = params.getObjId("objDefender");
        if (!space_utils.isPlayerControlledShip(self))
        {
            return SCRIPT_CONTINUE;
        }
        Vector objOfficers = space_utils.getShipOfficers(self);
        for (int intI = 0; intI < objOfficers.size(); intI++)
        {
            space_utils.notifyObject(((obj_id)objOfficers.get(intI)), "targetDisabled", params);
            space_utils.sendSystemMessageShip(self, SID_TARGET_DISABLED, true, true, true, false);
        }
        return SCRIPT_CONTINUE;
    }
    public int disableSelf(obj_id self, dictionary params) throws InterruptedException
    {
        obj_id objAttacker = params.getObjId("objShip");
        float fltRemainingDamage = space_combat.doComponentDamage(objAttacker, self, 0, ship_chassis_slot_type.SCST_reactor, 500000, 0);
        return SCRIPT_CONTINUE;
    }
    public int megaDamage(obj_id self, dictionary params) throws InterruptedException
    {
        obj_id objAttacker = params.getObjId("objShip");
        if (space_utils.isPlayerControlledShip(objAttacker))
        {
            obj_id objPilot = getPilotId(objAttacker);
            if (isIdValid(objPilot))
            {
                if (!isGod(objPilot))
                {
                    if (!utils.hasLocalVar(self, "intEjecting"))
                    {
                        return SCRIPT_CONTINUE;
                    }
                    else 
                    {
                        CustomerServiceLog("space_death", "%TU " + objAttacker + " is EJECTING!", getOwner(objAttacker));
                        utils.removeLocalVar(self, "intEjecting");
                        float fltDamage = getShipMaximumChassisHitPoints(self) * .20f;
                        space_combat.doChassisDamage(objAttacker, self, 1, fltDamage);
                        obj_id objDefenderPilot = getPilotId(self);
                        if (!isIdValid(objDefenderPilot))
                        {
                            objDefenderPilot = getOwner(self);
                        }
                        space_combat.sendDestructionNotification(self, objAttacker);
                        float fltIntensity = rand(0, 1.0f);
                        handleShipDestruction(self, fltIntensity);
                        messageTo(self, "killSpacePlayer", null, space_combat.SPACE_DEATH_DELAY, true);
                        space_combat.doDeathCleanup(self);
                    }
                }
            }
        }
        float fltDamage = 200000;
        int intSide = 1;
        int intTargetedComponent = 112;
        int intWeaponSlot = space_crafting.WEAPON_0;
        space_combat.doArmorDamage(objAttacker, self, intWeaponSlot, fltDamage, intSide);
        space_combat.doComponentDamage(objAttacker, self, intWeaponSlot, intTargetedComponent, fltDamage, intSide);
        space_combat.doChassisDamage(objAttacker, self, 0, fltDamage);
        if (!space_utils.isPlayerControlledShip(self))
        {
            space_combat.grantRewardsAndCreditForKills(self);
            space_combat.targetDestroyed(self);
            return SCRIPT_CONTINUE;
        }
        else 
        {
            obj_id objDefenderPilot = getPilotId(self);
            if (!isIdValid(objDefenderPilot))
            {
                objDefenderPilot = getOwner(self);
            }
            if (space_utils.isPlayerControlledShip(objAttacker))
            {
                utils.setScriptVar(self, "intPVPKill", 1);
            }
            space_combat.setDeathFlags(self);
            dictionary dctParams = new dictionary();
            dctParams.put("objAttacker", objAttacker);
            dctParams.put("objShip", self);
            space_utils.notifyObject(objDefenderPilot, "playerShipDestroyed", dctParams);
            float fltIntensity = rand(0, 1.0f);
            handleShipDestruction(self, fltIntensity);
            messageTo(self, "killSpacePlayer", null, space_combat.SPACE_DEATH_DELAY, true);
            space_combat.doDeathCleanup(self);
            CustomerServiceLog("space_death", "%TU " + self + " Has been killed by " + objAttacker, getOwner(objAttacker));
            if (space_battlefield.isInBattlefield(self))
            {
                CustomerServiceLog("battlefield", "%TU " + self + " Has been killed by " + objAttacker, getOwner(objAttacker));
            }
        }
        return SCRIPT_CONTINUE;
    }
    public int OnTryToEquipDroidControlDeviceInShip(obj_id self, obj_id objPlayer, obj_id objControlDevice) throws InterruptedException
    {
        if (!isIdValid(objControlDevice))
        {
            return SCRIPT_CONTINUE;
        }
        if (space_crafting.isUsableAstromechPet(objControlDevice))
        {
            if (space_crafting.isCertifiedForAstromech(objControlDevice, objPlayer))
            {
                if (space_crafting.isUsingCorrectComputer(objControlDevice, self))
                {
                    if (isShipSlotInstalled(self, ship_chassis_slot_type.SCST_droid_interface))
                    {
                        if (!isShipComponentDisabled(self, ship_chassis_slot_type.SCST_droid_interface))
                        {
                            associateDroidControlDeviceWithShip(self, objControlDevice);
                        }
                        else 
                        {
                            string_id strSpam = new string_id("space/space_interaction", "droid_interface_disabled");
                            sendSystemMessage(objPlayer, strSpam);
                            associateDroidControlDeviceWithShip(self, objControlDevice);
                        }
                        return SCRIPT_CONTINUE;
                    }
                    else 
                    {
                        associateDroidControlDeviceWithShip(self, objControlDevice);
                        string_id strSpam = new string_id("space/space_interaction", "no_droid_command_module");
                        sendSystemMessage(objPlayer, strSpam);
                        return SCRIPT_CONTINUE;
                    }
                }
                else 
                {
                    if (hasObjVar(objControlDevice, "pet.creatureName"))
                    {
                        string_id strSpam = new string_id("space/space_interaction", "need_flight_computer");
                        sendSystemMessage(objPlayer, strSpam);
                    }
                    else 
                    {
                        string_id strSpam = new string_id("space/space_interaction", "need_astromech");
                        sendSystemMessage(objPlayer, strSpam);
                    }
                }
            }
            else 
            {
                string_id strSpam = new string_id("space/space_interaction", "droid_not_certified");
                sendSystemMessage(objPlayer, strSpam);
                return SCRIPT_CONTINUE;
            }
        }
        else 
        {
            string_id strSpam = new string_id("space/space_interaction", "not_an_astromech_for_space");
            sendSystemMessage(objPlayer, strSpam);
        }
        return SCRIPT_CONTINUE;
    }
    public int OnShipComponentUninstalling(obj_id self, obj_id uninstallerId, int intSlot, obj_id targetContainer) throws InterruptedException
    {
        if (intSlot == ship_component_type.SCT_droid_interface)
        {
            obj_id objDroidControlDevice = getDroidControlDeviceForShip(self);
            if (isIdValid(objDroidControlDevice))
            {
                removeDroidControlDeviceFromShip(self);
            }
        }
        return SCRIPT_CONTINUE;
    }
    public int OnShipComponentUninstalled(obj_id self, obj_id uninstallerId, obj_id componentId, int slot, obj_id targetContainer) throws InterruptedException
    {
        if (slot == ship_chassis_slot_type.SCST_cargo_hold)
        {
            removeObjVar(self, "ship_comp.cargo_hold.contents_types");
            removeObjVar(self, "ship_comp.cargo_hold.contents_amounts");
            setObjVar(self, "ship_comp.cargo_hold.contents_current", (int)0);
        }
        return SCRIPT_CONTINUE;
    }
    public int OnDroppedItemOntoShipComponent(obj_id self, int intSlot, obj_id objItem, obj_id objPlayer) throws InterruptedException
    {
        if (hasObjVar(objItem, "weapon.intAmmoType"))
        {
            if (space_crafting.isWeaponAmmo(objItem))
            {
                if (space_crafting.isProperAmmoForWeapon(objItem, self, intSlot))
                {
                    space_crafting.applyAmmoToWeapon(self, objItem, intSlot, objPlayer, true);
                }
                else 
                {
                    string_id strSpam = new string_id("space/space_interaction", "no_ammo_allowed");
                    sendSystemMessage(objPlayer, strSpam);
                    return SCRIPT_CONTINUE;
                }
            }
            else 
            {
                string_id strSpam = new string_id("space/space_interaction", "not_missile_ammo");
                sendSystemMessage(objPlayer, strSpam);
                return SCRIPT_CONTINUE;
            }
        }
        return SCRIPT_CONTINUE;
    }
    public int notifyOnDestroy(obj_id self, dictionary params) throws InterruptedException
    {
        if (params == null)
        {
            return SCRIPT_CONTINUE;
        }
        obj_id obj = params.getObjId("object");
        if (!isIdValid(obj))
        {
            return SCRIPT_CONTINUE;
        }
        obj_id[] notifyobjs = getObjIdArrayObjVar(self, "destroynotify");
        obj_id[] newnotifyobjs = null;
        if (notifyobjs == null)
        {
            newnotifyobjs = new obj_id[1];
            newnotifyobjs[0] = obj;
        }
        else 
        {
            newnotifyobjs = new obj_id[notifyobjs.length + 1];
            for (int i = 0; i < notifyobjs.length; i++)
            {
                newnotifyobjs[i] = notifyobjs[i];
            }
            newnotifyobjs[notifyobjs.length] = obj;
        }
        setObjVar(self, "destroynotify", newnotifyobjs);
        return SCRIPT_CONTINUE;
    }
    public int OnShipDisabled(obj_id self, dictionary params) throws InterruptedException
    {
        obj_id objAttacker = params.getObjId("objAttacker");
        if (hasScript(self, "space.ai.space_ai"))
        {
            ship_ai.unitIdle(self);
            ship_ai.unitSetAttackOrders(self, ship_ai.ATTACK_ORDERS_HOLD_FIRE);
            detachScript(self, "space.ai.space_ai");
            dictionary outparams = new dictionary();
            outparams.put("attacker", objAttacker);
            messageTo(self, "selfDestruct", outparams, 120.f + rand() * 60.f, false);
            if (!hasObjVar(self, "objMissionOwner"))
            {
                setObjVar(self, "objMissionOwner", getPilotId(objAttacker));
            }
        }
        return SCRIPT_CONTINUE;
    }
    public int selfDestruct(obj_id self, dictionary params) throws InterruptedException
    {
        removeObjVar(self, "objMissionOwner");
        if (utils.hasScriptVar(self, "being_docked"))
        {
            messageTo(self, "selfDestruct", params, 30.f, false);
            return SCRIPT_CONTINUE;
        }
        setObjVar(self, "selfDestruct", 1);
        obj_id attacker = params.getObjId("attacker");
        if (isIdValid(attacker))
        {
            if ((!exists(attacker) || (!attacker.isLoaded())))
            {
                attacker = self;
            }
        }
        space_combat.doChassisDamage(attacker, self, 0, 45000000);
        space_combat.targetDestroyed(self);
        return SCRIPT_CONTINUE;
    }
    public int reactorPumpPulseTimeout(obj_id self, dictionary params) throws InterruptedException
    {
        obj_id ship = params.getObjId("ship");
        int pumpPulseLoops = params.getInt("loops");
        obj_id pilot = params.getObjId("pilot");
        debugServerConsoleMsg(null, "+++ SPACE COMMAND . combat_ship.reactorPumpPulseTimeout +++ ARRIVED in messagehandler. ObjID of ship was: " + ship + " objID of pilot was: " + pilot + " number of loops was: " + pumpPulseLoops);
        if (pumpPulseLoops > 1)
        {
            string_id strSpam = new string_id("space/space_interaction", "power_spike");
            space_utils.sendSystemMessageShip(self, strSpam, true, false, true, true);
            --pumpPulseLoops;
            params.put("ship", ship);
            params.put("loops", pumpPulseLoops);
            params.put("pilot", pilot);
            messageTo(self, "reactorPumpPulseTimeout", params, 5.0f, false);
        }
        else if (pumpPulseLoops == 1)
        {
            string_id strSpam = new string_id("space/space_interaction", "reactor_normalizing");
            space_utils.sendSystemMessageShip(self, strSpam, true, false, true, true);
            --pumpPulseLoops;
            params.put("ship", ship);
            params.put("loops", pumpPulseLoops);
            params.put("pilot", pilot);
            messageTo(self, "reactorPumpPulseTimeout", params, 5.0f, false);
        }
        else 
        {
            if (isIdValid(ship))
            {
                string_id strSpam = new string_id("space/space_interaction", "reactor_stabilized");
                space_utils.sendSystemMessageShip(self, strSpam, true, false, true, true);
                space_pilot_command.allPurposeShipComponentReset(ship);
                utils.removeScriptVar(pilot, "cmd.reactorPumpPulse");
            }
            else 
            {
                debugServerConsoleMsg(null, "+++ MH reactorPumpPulseTimeout . obj_id of the ship passed into the reactor reset function doesn't come back as valid. What the!?.");
            }
        }
        return SCRIPT_CONTINUE;
    }
    public int unScramReactor(obj_id self, dictionary params) throws InterruptedException
    {
        obj_id ship = params.getObjId("ship");
        int scramLoops = params.getInt("loops");
        obj_id pilot = params.getObjId("pilot");
        if (scramLoops > 1)
        {
            string_id strSpam = new string_id("space/space_interaction", "reactor_standby");
            space_utils.sendSystemMessageShip(self, strSpam, true, false, true, true);
            String cefPlayBackHardpoint = space_combat.targetHardpointForCefPlayback(ship);
            playClientEffectObj(pilot, "clienteffect/space_command/scram_reactor_shutdown_alarm.cef", ship, cefPlayBackHardpoint);
            --scramLoops;
            params.put("ship", ship);
            params.put("loops", scramLoops);
            params.put("pilot", pilot);
            messageTo(self, "unScramReactor", params, 5.0f, false);
        }
        else if (scramLoops == 1)
        {
            string_id strSpam = new string_id("space/space_interaction", "beginning_reactor_restart");
            space_utils.sendSystemMessageShip(self, strSpam, true, false, true, true);
            String cefPlayBackHardpoint = space_combat.targetHardpointForCefPlayback(ship);
            playClientEffectObj(pilot, "clienteffect/space_command/scram_reactor_startup_engine.cef", ship, cefPlayBackHardpoint);
            --scramLoops;
            params.put("ship", ship);
            params.put("loops", scramLoops);
            params.put("pilot", pilot);
            messageTo(self, "unScramReactor", params, 8.0f, false);
        }
        else 
        {
            space_pilot_command.allPurposeShipComponentReset(ship);
            utils.removeScriptVar(pilot, "cmd.reactorPumpPulse");
        }
        return SCRIPT_CONTINUE;
    }
    public int OnShipComponentPowerSufficient(obj_id self, int intSlot, float fltPowerReceived) throws InterruptedException
    {
        obj_id objPilot = getPilotId(self);
        float fltCurrentHitPoints = getShipComponentHitpointsCurrent(self, intSlot);
        if (fltCurrentHitPoints > 0)
        {
            space_utils.setComponentDisabled(self, intSlot, false);
            space_combat.recalculateEfficiency(intSlot, self);
        }
        return SCRIPT_CONTINUE;
    }
    public int OnShipComponentPowerInsufficient(obj_id self, int intSlot, float fltPowerRequired, float fltPowerReceived) throws InterruptedException
    {
        if (fltPowerRequired == 0)
        {
            fltPowerRequired = 1.0f;
        }
        float fltTest = fltPowerReceived / fltPowerRequired;
        if (fltTest < space_combat.MINIMUM_EFFICIENCY)
        {
            space_utils.setComponentDisabled(self, intSlot, true);
            setShipComponentDisabledNeedsPower(self, intSlot, true);
        }
        else 
        {
            space_combat.recalculateEfficiencyGeneral(intSlot, self, fltTest);
        }
        return SCRIPT_CONTINUE;
    }
    public int OnShipComponentInstalling(obj_id self, obj_id installerId, obj_id componentId, int slot) throws InterruptedException
    {
        obj_id owner = getOwner(self);
        if (isIdValid(owner))
        {
            if (!hasCertificationsForItem(owner, self))
            {
                string_id strSpam = new string_id("space/space_interaction", "certification_ship_none");
                space_utils.sendSystemMessageShip(self, strSpam, true, false, true, true);
                return SCRIPT_OVERRIDE;
            }
            else 
            {
                if (!hasCertificationsForItem(owner, componentId))
                {
                    string_id strSpam = new string_id("space/space_interaction", "certification_ordnance_none");
                    space_utils.sendSystemMessageShip(self, strSpam, true, false, true, true);
                    return SCRIPT_OVERRIDE;
                }
            }
            if (!isGameObjectTypeOf(componentId, GOT_ship_component_modification))
            {
                if (hasObjVar(componentId, "ship_comp.mass"))
                {
                    float componentMass = space_crafting.getComponentMass(componentId);
                    if (componentMass == 0)
                    {
                        string_id strSpam = new string_id("space/space_interaction", "installing_zero_mass_component");
                        space_utils.sendSystemMessageShip(self, strSpam, true, false, true, true);
                        return SCRIPT_OVERRIDE;
                    }
                }
            }
        }
        else 
        {
            debugServerConsoleMsg(null, "+++ COMBAT_SHIP.OnShipComponentInstalling +++ Unable to find ships owner, so cannot check certifications. What the!?.");
        }
        return SCRIPT_CONTINUE;
    }
    public int OnShipComponentInstalled(obj_id self, obj_id objInstaller, int intSlot) throws InterruptedException
    {
        if (intSlot == space_crafting.ENGINE)
        {
            space_crafting.setupChassisDifferentiation(self);
        }
        space_pilot_command.allPurposeShipComponentReset(self);
        int currentSlotComponentType = ship_chassis_slot_type.getComponentTypeForSlot(intSlot);
        if (currentSlotComponentType == ship_component_type.SCT_weapon)
        {
            int flags = getShipComponentFlags(self, intSlot);
            boolean isBitSet = (flags & ship_component_flags.SCF_reverse_engineered) != 0;
            obj_id player = utils.getContainingPlayer(self);
            if (isBitSet)
            {
                space_crafting.recalculateFireRateFromSlot(player, self, intSlot);
            }
        }
        return SCRIPT_CONTINUE;
    }
    public int OnShipFiredCountermeasure(obj_id self, int intWeaponIndex, obj_id objPlayer) throws InterruptedException
    {
        int intSlot = intWeaponIndex + ship_chassis_slot_type.SCST_weapon_first;
        float fltMinDefense = getShipWeaponDamageMaximum(self, intSlot);
        float fltMaxDefense = getShipWeaponDamageMaximum(self, intSlot);
        float fltRoll = rand(fltMinDefense, fltMaxDefense);
        int intMissile = getNearestUnlockedMissileForTarget(self);
        if (intMissile == 0)
        {
            launchCountermeasure(self, 0, false, 0);
        }
        else 
        {
            if (fltRoll > getMissileDefenseRoll(intMissile))
            {
                launchCountermeasure(self, intMissile, true, 0);
            }
            else 
            {
                launchCountermeasure(self, intMissile, false, 0);
            }
        }
        applyFiredWeaponsSkillMod(self);
        return SCRIPT_CONTINUE;
    }
    public int OnShipFiredMissile(obj_id self, int intMissileId, int intWeaponIndex, int intMissileType, obj_id objPilot, obj_id objDefender, int intTargetedSlot) throws InterruptedException
    {
        int intSlot = intWeaponIndex + ship_chassis_slot_type.SCST_weapon_first;
        if (isIdValid(objPilot))
        {
            if (utils.checkConfigFlag("ScriptFlags", "e3Demo"))
            {
                setShipWeaponAmmoCurrent(self, intSlot, getShipWeaponAmmoCurrent(self, intSlot));
                return SCRIPT_CONTINUE;
            }
            applyFiredWeaponsSkillMod(self);
        }
        return SCRIPT_CONTINUE;
    }
    public int getMissileDefenseRoll(int intMissileId) throws InterruptedException
    {
        int intMissileType = getTypeByMissile(intMissileId);
        dictionary dctRow = dataTableGetRow("datatables/space/missiles.iff", intMissileType);
        return (dctRow.getInt("intCountermeasureDifficulty"));
    }
    public int flightDroidVocalize(obj_id self, dictionary params) throws InterruptedException
    {
        obj_id ship = params.getObjId("ship");
        int vocalizePriority = params.getInt("vocalizePriority");
        if (space_utils.isPlayerControlledShip(self))
        {
            space_combat.flightDroidVocalize(ship, vocalizePriority);
        }
        return SCRIPT_CONTINUE;
    }
    public int emergencyPowerTimeout(obj_id self, dictionary params) throws InterruptedException
    {
        obj_id ship = params.getObjId("ship");
        obj_id pilot = params.getObjId("pilot");
        float emergencyPowerTime = params.getFloat("emergencyPowerTime");
        if (!isIdValid(ship))
        {
            debugServerConsoleMsg(null, "+++ MH emergencyPowerTimeout . obj_id of the ship passed into the emergency power timeout function doesn't come back as valid. What the!?.");
            return SCRIPT_CONTINUE;
        }
        string_id strSpam = new string_id("space/space_interaction", "emergency_reset");
        space_utils.sendSystemMessageShip(self, strSpam, true, false, true, true);
        String cefPlayBackHardpoint = space_combat.targetHardpointForCefPlayback(ship);
        playClientEffectObj(self, "clienteffect/space_command/emergency_power_off.cef", ship, cefPlayBackHardpoint);
        space_pilot_command.allPurposeShipComponentReset(ship);
        if (utils.hasLocalVar(ship, "cmd.emergWeapon"))
        {
            utils.removeLocalVar(ship, "cmd.emergWeapon");
        }
        if (utils.hasLocalVar(ship, "cmd.emergShields"))
        {
            utils.removeLocalVar(ship, "cmd.emergShields");
        }
        if (utils.hasLocalVar(ship, "cmd.emergThrust"))
        {
            utils.removeLocalVar(ship, "cmd.emergThrust");
        }
        return SCRIPT_CONTINUE;
    }
    public void applyFiredWeaponsSkillMod(obj_id ship) throws InterruptedException
    {
        if (!utils.hasLocalVar(ship, "cmd.firedWeaponsSkillMod"))
        {
            int time = getGameTime();
            utils.setLocalVar(ship, "cmd.firedWeaponsSkillMod", SHIP_FIRED_SKILLMOD_PENALTY_TIME + time);
        }
        return;
    }
    public int componentsStunned(obj_id self, dictionary params) throws InterruptedException
    {
        Vector stunnedComponents = params.getResizeableIntArray("stunned_components");
        int stunDuration = params.getInt("stun_loops");
        obj_id pilot = null;
        String cefPlayBackHardpoint = space_combat.targetHardpointForCefPlayback(self);
        boolean boolPlayerShip = false;
        if (!space_utils.isPlayerControlledShip(self))
        {
            boolPlayerShip = true;
        }
        if (stunDuration > 20)
        {
            if (boolPlayerShip)
            {
                playClientEffectObj(self, "clienteffect/space_command/cbt_impact_emp_hvy.cef", self, "");
                if (stunnedComponents.size() > 1)
                {
                    string_id strSpam = new string_id("space/space_pilot_command", "multiple_systems_disrupted");
                    space_utils.sendSystemMessageShip(self, strSpam, true, false, true, true);
                }
                else 
                {
                    string_id strSpam = new string_id("space/space_pilot_command", "system_disrupted");
                    space_utils.sendSystemMessageShip(self, strSpam, true, false, true, true);
                }
            }
            else 
            {
                playClientEffectObj(self, "clienteffect/space_command/cbt_impact_emp_hvy_noshake.cef", self, "");
            }
        }
        else if (stunDuration < 20 && stunDuration > 0)
        {
            if (boolPlayerShip)
            {
                string_id strSpam = new string_id("space/space_pilot_command", "disrupted_standby");
                space_utils.sendSystemMessageShip(self, strSpam, true, false, true, true);
            }
        }
        else 
        {
            if (boolPlayerShip)
            {
                string_id strSpam = new string_id("space/space_pilot_command", "sub_system_restart");
                space_utils.sendSystemMessageShip(self, strSpam, true, false, true, true);
            }
            for (int i = 0; i < stunnedComponents.size(); i++)
            {
                space_utils.setComponentDisabled(self, ((Integer)stunnedComponents.get(i)).intValue(), false);
                space_combat.recalculateEfficiency(((Integer)stunnedComponents.get(i)).intValue(), self);
            }
            return SCRIPT_CONTINUE;
        }
        stunDuration--;
        params.put("stunned_components", stunnedComponents);
        params.put("stun_loops", stunDuration);
        messageTo(self, "componentsStunned", params, STUNNED_COMPONENT_LOOP_TIME, false);
        return SCRIPT_CONTINUE;
    }
    public int vRepairDamageCEFLoop(obj_id self, dictionary params) throws InterruptedException
    {
        int damageLoops = params.getInt("damage_loops");
        obj_id pilot = params.getObjId("pilot");
        debugServerConsoleMsg(null, "vRepairDamageCEFLoop **********  just entered message handler. Recieved number of loops of: " + damageLoops + " and pilot objId of: " + pilot);
        String cefPlayBackHardpoint = space_combat.targetHardpointForCefPlayback(self);
        String clientEffect = space_pilot_command.randomWeldingCEFPicker();
        debugServerConsoleMsg(null, "vRepairDamageCEFLoop **********  cef chosen for playback is " + clientEffect);
        transform t = new transform();
        t = t.move_p(new vector(0.0f, 1.7f, 0.0f));
        debugServerConsoleMsg(null, "vRepairDamageCEFLoop **********  DID CRAZY TRANSFORM STUFF. HERE COMES THE EFFECT!!! ");
        if (!playClientEffectObj(pilot, clientEffect, self, null, t))
        {
            debugServerConsoleMsg(null, "vRepairDamageCEFLoop **********  FAILED TO PLAYBACK CEF ");
        }
        damageLoops--;
        if (damageLoops > 0)
        {
            params.put("damage_loops", damageLoops);
            params.put("pilot", pilot);
            messageTo(self, "vRepairDamageCEFLoop", params, 3.0f, false);
        }
        return SCRIPT_CONTINUE;
    }
    public int OnSpaceUnitDocked(obj_id self, obj_id target) throws InterruptedException
    {
        obj_id objPilot = getPilotId(self);
        if (!space_utils.isPlayerControlledShip(self))
        {
            return SCRIPT_CONTINUE;
        }
        dictionary outparams = new dictionary();
        outparams.put("target", target);
        space_utils.notifyObject(objPilot, "spaceUnitDocked", outparams);
        return SCRIPT_CONTINUE;
    }
    public int OnSpaceUnitUnDocked(obj_id self, obj_id target, boolean dockSuccessful) throws InterruptedException
    {
        obj_id objPilot = getPilotId(self);
        if (!space_utils.isPlayerControlledShip(self))
        {
            return SCRIPT_CONTINUE;
        }
        dictionary outparams = new dictionary();
        outparams.put("target", target);
        if (dockSuccessful)
        {
            space_utils.notifyObject(objPilot, "spaceUnitUnDocked", outparams);
        }
        else 
        {
            space_utils.notifyObject(objPilot, "spaceUnitDockingFailed", outparams);
        }
        return SCRIPT_CONTINUE;
    }
    public int openComm(obj_id self, dictionary params) throws InterruptedException
    {
        obj_id objStation = params.getObjId("objStation");
        obj_id objPilot = getPilotId(self);
        queueCommand(objPilot, (80588750), objStation, "0   ", COMMAND_PRIORITY_FRONT);
        return SCRIPT_CONTINUE;
    }
    public int OnSpeaking(obj_id self, String strText) throws InterruptedException
    {
        obj_id objPilot = getPilotId(self);
        if (isIdValid(objPilot))
        {
            if (isGod(objPilot) || (utils.checkConfigFlag("scriptFlags", "e3Demo")))
            {
                Object[] newParams = new Object[2];
                newParams[0] = objPilot;
                newParams[1] = strText;
                space_utils.callTrigger("OnSpeaking", newParams);
            }
        }
        return SCRIPT_CONTINUE;
    }
    public int checkSpacePVPStatus(obj_id self, dictionary params) throws InterruptedException
    {
        space_transition.updatePVPStatus(self);
        return SCRIPT_CONTINUE;
    }
    public int destroySelf(obj_id self, dictionary params) throws InterruptedException
    {
        setObjVar(self, "intCleaningUp", 1);
        destroyObject(self);
        return SCRIPT_CONTINUE;
    }
}