CombatEngineAPI.java

Go to the documentation of this file.

package com.fs.starfarer.api.combat;
 
import java.util.List;
import java.util.Map;
 
import java.awt.Color;
 
import org.lwjgl.util.vector.Vector2f;
 
import com.fs.starfarer.api.campaign.CombatDamageData;
import com.fs.starfarer.api.combat.EmpArcEntityAPI.EmpArcParams;
import com.fs.starfarer.api.combat.WeaponAPI.WeaponType;
import com.fs.starfarer.api.combat.listeners.CombatListenerManagerAPI;
import com.fs.starfarer.api.loading.DamagingExplosionSpec;
import com.fs.starfarer.api.loading.WeaponSlotAPI;
import com.fs.starfarer.api.loading.WeaponSpecAPI;
import com.fs.starfarer.api.mission.FleetSide;
 
public interface CombatEngineAPI {
    
    boolean isInCampaign();
    
    boolean isInCampaignSim();
    
    CombatUIAPI getCombatUI();
    
    void setHyperspaceMode();
    
    @Deprecated
    List<BattleObjectiveAPI> getAllObjectives();
    @Deprecated
    List<ShipAPI> getAllShips();
    
    List<BattleObjectiveAPI> getObjectives();
    List<ShipAPI> getShips();
    List<MissileAPI> getMissiles();
    List<CombatEntityAPI> getAsteroids();
    List<BeamAPI> getBeams();
    List<DamagingProjectileAPI> getProjectiles();
    
    boolean isEntityInPlay(CombatEntityAPI entity);
    
    FogOfWarAPI getFogOfWar(int owner);
    
    void removeEntity(CombatEntityAPI entity);
    
    CombatFleetManagerAPI getFleetManager(FleetSide side);
    CombatFleetManagerAPI getFleetManager(int owner);
    
    ShipAPI getPlayerShip();
    
    boolean isPaused();
    
    void endCombat(float delay);
    void setDoNotEndCombat(boolean doNotEndCombat);
    void endCombat(float delay, FleetSide winner);
    
    
    ViewportAPI getViewport();
    
    void applyDamage(CombatEntityAPI entity, Vector2f point, 
                     float damageAmount, DamageType damageType, float empAmount,
                     boolean bypassShields, boolean dealsSoftFlux, 
                     Object source, boolean playSound);
    
    void applyDamage(CombatEntityAPI entity, Vector2f point, 
            float damageAmount, DamageType damageType, float empAmount,
            boolean bypassShields, boolean dealsSoftFlux, 
            Object source);
    
    void applyDamage(Object damageModifierParam, CombatEntityAPI entity, Vector2f point, 
            float damageAmount, DamageType damageType, float empAmount,
            boolean bypassShields, boolean dealsSoftFlux, 
            Object source, boolean playSound);
    
    void addHitParticle(Vector2f loc, Vector2f vel, float size, float brightness, float duration, Color color);
    public void addSmoothParticle(Vector2f loc, Vector2f vel, float size, float brightness, float duration, Color color);
    
    public void addSmokeParticle(Vector2f loc, Vector2f vel, float size, float opacity, float duration, Color color);
    
    
    void spawnExplosion(Vector2f loc, Vector2f vel, Color color, float size, float maxDuration);
    
    CombatEntityAPI spawnAsteroid(int size, float x, float y, float dx, float dy);
    
    
    void addFloatingText(Vector2f loc, String text, float size, Color color, CombatEntityAPI attachedTo, float flashFrequency, float flashDuration);
    void addFloatingDamageText(Vector2f loc, float damage, Color color, CombatEntityAPI attachedTo, CombatEntityAPI damageSource);
    
    
    
    public CombatEntityAPI spawnProjectile(ShipAPI ship, WeaponAPI weapon, String weaponId,
                                           Vector2f point, float angle, Vector2f shipVelocity);
    
    
    public EmpArcEntityAPI spawnEmpArc(ShipAPI damageSource,
                                        Vector2f point,
                                        CombatEntityAPI pointAnchor,
                                        CombatEntityAPI empTargetEntity,
                                        DamageType damageType,
                                        float damAmount,
                                        float empDamAmount,
                                        float maxRange,
                                        String impactSoundId,
                                        float thickness,
                                        Color fringe, Color core);
    
    public EmpArcEntityAPI spawnEmpArc(ShipAPI damageSource,
            Vector2f point,
            CombatEntityAPI pointAnchor,
            CombatEntityAPI empTargetEntity,
            DamageType damageType,
            float damAmount,
            float empDamAmount,
            float maxRange,
            String impactSoundId,
            float thickness,
            Color fringe, Color core, EmpArcParams params);
    
    public EmpArcEntityAPI spawnEmpArcPierceShields(ShipAPI damageSource,
                                                    Vector2f point, CombatEntityAPI pointAnchor,
                                                    CombatEntityAPI empTargetEntity, DamageType damageType,
                                                    float damAmount, float empDamAmount, float maxRange,
                                                    String impactSoundId, float thickness, Color fringe, Color core);   
    public EmpArcEntityAPI spawnEmpArcPierceShields(ShipAPI damageSource,
            Vector2f point, CombatEntityAPI pointAnchor,
            CombatEntityAPI empTargetEntity, DamageType damageType,
            float damAmount, float empDamAmount, float maxRange,
            String impactSoundId, float thickness, Color fringe, Color core, EmpArcParams params);  
    
    
    float getMapWidth();
    float getMapHeight();
    
    BattleCreationContext getContext();
    
    
    float getTotalElapsedTime(boolean includePaused);
    
    float getElapsedInLastFrame();
    
    void addPlugin(EveryFrameCombatPlugin plugin);
    
    void removePlugin(EveryFrameCombatPlugin plugin);
 
    boolean isSimulation();
    boolean isMission();
    String getMissionId();
 
 
    void setPlayerShipExternal(ShipAPI ship);
    boolean isUIShowingDialog();
    boolean isUIShowingHUD();
    boolean isUIAutopilotOn();
 
    
    float getElapsedInContactWithEnemy();
 
    boolean isFleetsInContact();
 
    void setSideDeploymentOverrideSide(FleetSide sideDeploymentOverrideSide);
 
    Map<String, Object> getCustomData();
 
    void maintainStatusForPlayerShip(Object key, String spriteName, String title, String data, boolean isDebuff);
 
    void setPaused(boolean paused);
 
    boolean playerHasNonAllyReserves();
 
    boolean playerHasAllyReserves();
 
    CombatDamageData getDamageData();
 
    MutableStat getTimeMult();
 
    void setMaxFleetPoints(FleetSide side, int fleetPoints);
 
    CombatNebulaAPI getNebula();
 
    boolean isInFastTimeAdvance();
 
    CombatEntityAPI spawnProjectile(ShipAPI ship, WeaponAPI weapon,
            String weaponId, String projSpecId, Vector2f point, float angle,
            Vector2f shipVelocity);
 
    void updateStationModuleLocations(ShipAPI station);
 
    
    CollisionGridAPI getAllObjectGrid();
    CollisionGridAPI getShipGrid();
    CollisionGridAPI getMissileGrid();
    CollisionGridAPI getAsteroidGrid();
 
    DamagingProjectileAPI spawnDamagingExplosion(DamagingExplosionSpec spec, ShipAPI source, Vector2f location);
    DamagingProjectileAPI spawnDamagingExplosion(DamagingExplosionSpec spec, ShipAPI source, Vector2f location, boolean canDamageSource);
 
    int getWinningSideId();
    boolean isCombatOver();
 
    void removeObject(Object object);
 
    CombatEntityAPI addLayeredRenderingPlugin(CombatLayeredRenderingPlugin plugin);
 
    boolean isEnemyInFullRetreat();
 
 
    boolean isMissileAlive(MissileAPI missile);
 
    void spawnMuzzleFlashOrSmoke(ShipAPI ship, WeaponSlotAPI slot, WeaponSpecAPI spec, int barrel, float targetAngle);
 
    CollisionGridAPI getAiGridMissiles();
    CollisionGridAPI getAiGridShips();
    CollisionGridAPI getAiGridAsteroids();
 
    boolean isAwareOf(int owner, CombatEntityAPI other);
 
    void headInDirectionWithoutTurning(MissileAPI missile, float desiredHeading, float desiredSpeed);
 
    void headInDirectionWithoutTurning(ShipAPI ship, float desiredHeading, float desiredSpeed);
 
    Vector2f getAimPointWithLeadForAutofire(CombatEntityAPI from, float accuracyFactor, CombatEntityAPI to, float projSpeed);
 
    CombatListenerManagerAPI getListenerManager();
 
    void applyDamageModifiersToSpawnedProjectileWithNullWeapon(ShipAPI source, WeaponType type, boolean isBeam, DamageAPI damage);
 
    void addHitParticle(Vector2f loc, Vector2f vel, float size, float brightness, float durationIn, float totalDuration, Color color);
 
    void addHitParticle(Vector2f loc, Vector2f vel, float size, float brightness, Color color);
 
    EmpArcEntityAPI spawnEmpArcVisual(Vector2f from, CombatEntityAPI fromAnchor, Vector2f to, CombatEntityAPI toAnchor,
                                      float thickness, Color fringe, Color core);
    EmpArcEntityAPI spawnEmpArcVisual(Vector2f from, CombatEntityAPI fromAnchor, Vector2f to, CombatEntityAPI toAnchor,
            float thickness, Color fringe, Color core, EmpArcParams params);
 
    void addSmoothParticle(Vector2f loc, Vector2f vel, float size,
            float brightness, float rampUpFraction, float totalDuration,
            Color color);
 
    void addNegativeParticle(Vector2f loc, Vector2f vel, float size, float rampUpFraction, float totalDuration, Color color);
 
    void addNebulaParticle(Vector2f loc, Vector2f vel, float size,
            float endSizeMult, float rampUpFraction,
            float fullBrightnessFraction, float totalDuration, Color color);
 
    void addNegativeNebulaParticle(Vector2f loc, Vector2f vel, float size,
            float endSizeMult, float rampUpFraction,
            float fullBrightnessFraction, float totalDuration, Color color);
 
    void addNebulaSmokeParticle(Vector2f loc, Vector2f vel, float size,
            float endSizeMult, float rampUpFraction,
            float fullBrightnessFraction, float totalDuration, Color color);
 
    boolean hasAttachedFloaty(CombatEntityAPI entity);
 
    void addNebulaParticle(Vector2f loc, Vector2f vel, float size,
            float endSizeMult, float rampUpFraction,
            float fullBrightnessFraction, float totalDuration, Color color,
            boolean expandAsSqrt);
 
    void addSwirlyNebulaParticle(Vector2f loc, Vector2f vel, float size,
            float endSizeMult, float rampUpFraction,
            float fullBrightnessFraction, float totalDuration, Color color,
            boolean expandAsSqrt);
 
    void addNegativeSwirlyNebulaParticle(Vector2f loc, Vector2f vel,
            float size, float endSizeMult, float rampUpFraction,
            float fullBrightnessFraction, float totalDuration, Color color);
 
    boolean isInPlay(Object object);
 
    void setCombatNotOverForAtLeast(float seconds);
    void setCombatNotOverFor(float seconds);
    float getCombatNotOverFor();
 
    void setCustomExit(String buttonTitle, String confirmString);
    String getCustomExitButtonTitle();
    String getCustomExitButtonConfirmString();
 
    void addFloatingTextAlways(Vector2f loc, String text, float size, Color color, CombatEntityAPI attachedTo,
            float flashFrequency, float flashDuration, float durInPlace, float durFloatingUp, float durFadingOut, float baseAlpha);
 
    WeaponAPI createFakeWeapon(ShipAPI ship, String weaponId);
 
    ShipAPI getShipPlayerIsTransferringCommandFrom();
 
    ShipAPI getShipPlayerIsTransferringCommandTo();
 
    ShipAPI getShipPlayerLastTransferredCommandTo();
 
    ShipAPI createFXDrone(ShipVariantAPI variant);
 
    void addEntity(CombatEntityAPI entity);
 
    void addNebulaSmoothParticle(Vector2f loc, Vector2f vel, float size, float endSizeMult, float rampUpFraction,
            float fullBrightnessFraction, float totalDuration, Color color);
 
    void addNebulaSmoothParticle(Vector2f loc, Vector2f vel, float size, float endSizeMult, float rampUpFraction,
            float fullBrightnessFraction, float totalDuration, Color color, boolean expandAsSqrt);
 
    Color getBackgroundColor();
    void setBackgroundColor(Color backgroundColor);
    boolean isBackgroundGlowColorNonAdditive();
    void setBackgroundGlowColorNonAdditive(boolean backgroundGlowColorNonAdditive);
    void setBackgroundGlowColor(Color backgroundGlowColor);
    Color getBackgroundGlowColor();
    boolean isRenderStarfield();
    void setRenderStarfield(boolean renderStarfield);
 
    void setShipPlayerLastTransferredCommandTo(ShipAPI ship);
 
    void spawnMuzzleFlashOrSmoke(ShipAPI ship, Vector2f point, WeaponSpecAPI spec, float targetAngle);
 
    boolean isInMissionSim();
 
    boolean isShipAlive(ShipAPI ship);
 
    void spawnDebrisSmall(Vector2f loc, Vector2f vel, int num, float facing, float spread, float minVel, float velRange,
            float maxRotation);
    void spawnDebrisMedium(Vector2f loc, Vector2f vel, int num, float facing, float spread, float minVel,
            float velRange, float maxRotation);
    void spawnDebrisLarge(Vector2f loc, Vector2f vel, int num, float facing, float spread, float minVel, float velRange,
            float maxRotation);
 
    void addFloatingDamageText(Vector2f loc, float damage, float spread, Color color, CombatEntityAPI to,
                                    CombatEntityAPI source);
 
    MissileAIPlugin createProximityFuseAI(MissileAPI missile);
    String getBackgroundSpriteName();
 
    boolean isInEngine(ShipAPI ship);
 
    boolean hasPluginOfClass(Class c);
 
    void applyImpact(Vector2f vel, float impact, CombatEntityAPI target, Vector2f point);
 
    void playShipExplosionSound(ShipAPI ship);
 
    CombatEntityAPI spawnAsteroid(String spriteName, float x, float y, float dx, float dy, boolean fromRing);
    
    //float getElapsedInCurrentFrame();
 
}