package com.planet_ink.coffee_mud.Items.CompTech;
import com.planet_ink.coffee_mud.core.interfaces.*;
import com.planet_ink.coffee_mud.core.interfaces.BoundedObject.BoundedCube;
import com.planet_ink.coffee_mud.core.*;
import com.planet_ink.coffee_mud.core.CMSecurity.DbgFlag;
import com.planet_ink.coffee_mud.core.collections.*;
import com.planet_ink.coffee_mud.Abilities.interfaces.*;
import com.planet_ink.coffee_mud.Areas.interfaces.*;
import com.planet_ink.coffee_mud.Behaviors.interfaces.*;
import com.planet_ink.coffee_mud.CharClasses.interfaces.*;
import com.planet_ink.coffee_mud.Commands.interfaces.*;
import com.planet_ink.coffee_mud.Common.interfaces.*;
import com.planet_ink.coffee_mud.Exits.interfaces.*;
import com.planet_ink.coffee_mud.Items.BasicTech.StdElecItem;
import com.planet_ink.coffee_mud.Items.interfaces.*;
import com.planet_ink.coffee_mud.Items.interfaces.Technical.TechCommand;
import com.planet_ink.coffee_mud.Items.interfaces.Technical.TechType;
import com.planet_ink.coffee_mud.Libraries.interfaces.*;
import com.planet_ink.coffee_mud.Locales.interfaces.*;
import com.planet_ink.coffee_mud.MOBS.interfaces.*;
import com.planet_ink.coffee_mud.Races.interfaces.*;
import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.util.*;
/*
Copyright 2016-2016 Bo Zimmerman
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
public class StdShipShieldGenerator extends StdElecCompItem implements ShipShieldGenerator
{
@Override
public String ID()
{
return "StdShipShieldGenerator";
}
@Override
public TechType getTechType()
{
return Technical.TechType.SHIP_SHIELD;
}
private ShipDir[] allPossDirs = ShipDir.values();
private int numPermitDirs = ShipDir.values().length;
private int[] shieldedMsgTypes= AVAIL_DAMAGE_TYPES;
private volatile long lastPowerConsumption = 0;
private volatile long powerSetting = Integer.MAX_VALUE;
private volatile ShipDir[] currCoverage = null;
private volatile Reference<SpaceShip> myShip = null;
@Override
public void setOwner(ItemPossessor container)
{
super.setOwner(container);
myShip = null;
}
@Override
public int powerNeeds()
{
return (int) Math.min((int) Math.min(powerCapacity,powerSetting) - power, getRechargeRate());
}
protected synchronized SpaceShip getMyShip()
{
if(myShip == null)
{
final Area area = CMLib.map().areaLocation(this);
if(area instanceof SpaceShip)
myShip = new WeakReference<SpaceShip>((SpaceShip)area);
else
myShip = new WeakReference<SpaceShip>(null);
}
return myShip.get();
}
@Override
public void setPermittedDirections(ShipDir[] newPossDirs)
{
this.allPossDirs = newPossDirs;
}
@Override
public ShipDir[] getPermittedDirections()
{
return allPossDirs;
}
@Override
public void setPermittedNumDirections(int numDirs)
{
this.numPermitDirs = numDirs;
}
@Override
public int getPermittedNumDirections()
{
return numPermitDirs;
}
@Override
public void setShieldedMsgTypes(int[] newTypes)
{
this.shieldedMsgTypes = newTypes;
}
@Override
public int[] getShieldedMsgTypes()
{
return shieldedMsgTypes;
}
protected ShipDir[] getCurrentCoveredDirections()
{
if(this.currCoverage == null)
{
final ShipDir[] permitted = getPermittedDirections();
int numDirs = getPermittedNumDirections();
if(numDirs >= permitted.length)
currCoverage = getPermittedDirections();
else
{
int centralIndex = CMLib.dice().roll(1, numDirs, -1);
List<ShipDir> theDirs = new ArrayList<ShipDir>(numDirs);
int offset = 0;
final List<ShipDir> permittedDirs = new XVector<ShipDir>(permitted);
permittedDirs.addAll(Arrays.asList(permitted));
permittedDirs.addAll(Arrays.asList(permitted));
while(theDirs.size() < numDirs)
{
if(!theDirs.contains(permittedDirs.get(centralIndex+offset)))
theDirs.add(permittedDirs.get(centralIndex+offset));
if(!theDirs.contains(permittedDirs.get(centralIndex-offset)))
theDirs.add(permittedDirs.get(centralIndex-offset));
offset+=1;
}
currCoverage = theDirs.toArray(new ShipDir[theDirs.size()]);
}
}
return currCoverage;
}
@Override
public boolean okMessage(Environmental host, CMMsg msg)
{
if(!super.okMessage(host, msg))
return false;
final SpaceShip ship = getMyShip();
if((msg.target() == ship)
&&(activated())
&&(CMParms.contains(this.getShieldedMsgTypes(), msg.sourceMinor())))
{
switch(msg.targetMinor())
{
case CMMsg.TYP_DAMAGE: // laser, energy, some other kind of directed damage
{
if((msg.value() > 0)&&(this.lastPowerConsumption>0)&&(msg.tool() instanceof SpaceObject))
{
final SpaceObject weaponO=(SpaceObject)msg.tool();
// first decide if it came from a direction im handling
// if that matters
boolean absorbs = false;
if((getCurrentCoveredDirections().length >= ShipDir.values().length))
absorbs = true;
else
if(weaponO.knownSource() != null)
{
final double[] directionToMe = CMLib.map().getDirection(weaponO.knownSource(), ship);
final ShipDir dir = CMLib.map().getDirectionFromDir(ship.facing(), ship.roll(), directionToMe);
absorbs = CMParms.contains(getCurrentCoveredDirections(), dir);
}
if(absorbs)
{
double shieldHurtMultiplier = 1.0;
// this shield can handle it, do deal out any tech-diff adjustments
if(msg.tool() instanceof Technical)
{
if(this.techLevel() > ((Technical)msg.tool()).techLevel())
{
double pct = 1.0 - CMath.div(this.techLevel() - ((Technical)msg.tool()).techLevel(),10.0);
if(pct <= 0)
{
shieldHurtMultiplier = 0.0;
msg.setValue((int)Math.round(msg.value() * 0.05));
}
else
{
shieldHurtMultiplier = pct;
msg.setValue((int)Math.round(msg.value() * pct));
}
}
}
// next do actual shield-based mitigations
if(msg.value() > 0)
{
double pctShields = CMath.div(lastPowerConsumption,powerCapacity());
double efficiency = this.getFinalManufacturer().getEfficiencyPct();
double reliability = this.getFinalManufacturer().getReliabilityPct();
double wearAndTear = 1.0;
if(this.subjectToWearAndTear() && this.usesRemaining()<100)
wearAndTear =CMath.div(this.usesRemaining(), 100);
int newVal = (int)Math.round(msg.value() - CMath.mul(msg.value(), pctShields * efficiency * wearAndTear));
int shieldDamage = (int)Math.round(50.0 * shieldHurtMultiplier * (1.0-pctShields) * (1.0-reliability));
if(shieldDamage > 0)
{
CMMsg msg2=(CMMsg)msg.copyOf();
msg2.setValue(shieldDamage);
msg2.setTarget(this);
sendLocalMessage(msg2);
}
msg.setValue(newVal);
}
}
}
break;
}
}
}
return true;
}
protected static void sendComputerMessage(final ShipShieldGenerator me, final String circuitKey, final MOB mob, final Item controlI, final String code)
{
for(final Iterator<Computer> c=CMLib.tech().getComputers(circuitKey);c.hasNext();)
{
final Computer C=c.next();
if((controlI==null)||(C!=controlI.owner()))
{
final CMMsg msg2=CMClass.getMsg(mob, C, me, CMMsg.NO_EFFECT, null, CMMsg.MSG_ACTIVATE|CMMsg.MASK_CNTRLMSG, code, CMMsg.NO_EFFECT,null);
if(C.okMessage(mob, msg2))
C.executeMsg(mob, msg2);
}
}
}
@Override
public void executeMsg(Environmental myHost, CMMsg msg)
{
super.executeMsg(myHost, msg);
if(msg.amITarget(this))
{
switch(msg.targetMinor())
{
case CMMsg.TYP_DAMAGE:
{
if(this.subjectToWearAndTear() && (this.usesRemaining()<100) && (msg.value()>0))
{
int shieldDamage = msg.value();
if(shieldDamage > usesRemaining())
{
setUsesRemaining(0);
CMMsg msg2=CMClass.getMsg(msg.source(), this, this, CMMsg.NO_EFFECT, null, CMMsg.MSG_DEACTIVATE|CMMsg.MASK_CNTRLMSG, "", CMMsg.NO_EFFECT,null);
this.sendLocalMessage(msg2);
final String code=Technical.TechCommand.COMPONENTFAILURE.makeCommand(TechType.SHIP_SHIELD, "Failure: "+me.name()+": shield_failure.");
sendComputerMessage(this,circuitKey,msg.source(),null,code);
}
else
setUsesRemaining(usesRemaining()-shieldDamage);
}
break;
}
case CMMsg.TYP_ACTIVATE:
{
final LanguageLibrary lang=CMLib.lang();
final Software controlI=(msg.tool() instanceof Software)?((Software)msg.tool()):null;
final MOB mob=msg.source();
if(msg.targetMessage()==null)
{
powerSetting = powerCapacity();
}
else
{
final String[] parts=msg.targetMessage().split(" ");
final TechCommand command=TechCommand.findCommand(parts);
if(command==null)
reportError(this, controlI, mob, lang.L("@x1 does not respond.",me.name(mob)), lang.L("Failure: @x1: control failure.",me.name(mob)));
else
{
final Object[] parms=command.confirmAndTranslate(parts);
if(parms==null)
reportError(this, controlI, mob, lang.L("@x1 did not respond.",me.name(mob)), lang.L("Failure: @x1: control syntax failure.",me.name(mob)));
else
if(command == TechCommand.POWERSET)
{
powerSetting=((Long)parms[0]).intValue();
if(powerSetting<0)
powerSetting=0;
else
if(powerSetting > powerCapacity())
powerSetting = powerCapacity();
}
else
if(command == TechCommand.SHIELDSET)
{
ShipDir centerDir = (ShipDir)parms[0];
int centralIndex = CMParms.indexOf(this.getPermittedDirections(),centerDir);
if(centralIndex < 0)
reportError(this, controlI, mob, lang.L("@x1 did not respond.",me.name(mob)), lang.L("Failure: @x1: control port failure.",me.name(mob)));
else
{
int numDirs = ((Integer)parms[1]).intValue();
if(numDirs > this.getPermittedNumDirections())
numDirs = this.getPermittedNumDirections();
if(numDirs >= this.getPermittedDirections().length)
currCoverage = getPermittedDirections();
else
{
final List<ShipDir> permittedDirs = new XVector<ShipDir>(this.getPermittedDirections());
permittedDirs.addAll(Arrays.asList(this.getPermittedDirections()));
permittedDirs.addAll(Arrays.asList(this.getPermittedDirections()));
centralIndex += this.getPermittedDirections().length;
final List<ShipDir> theDirs = new ArrayList<ShipDir>(numDirs);
int offset = 0;
while(theDirs.size() < numDirs)
{
if(!theDirs.contains(permittedDirs.get(centralIndex+offset)))
theDirs.add(permittedDirs.get(centralIndex+offset));
if(!theDirs.contains(permittedDirs.get(centralIndex-offset)))
theDirs.add(permittedDirs.get(centralIndex-offset));
offset+=1;
}
currCoverage = theDirs.toArray(new ShipDir[theDirs.size()]);
}
}
}
else
reportError(this, controlI, mob, lang.L("@x1 refused to respond.",me.name(mob)), lang.L("Failure: @x1: control command failure.",me.name(mob)));
}
}
break;
}
case CMMsg.TYP_POWERCURRENT:
// shields should constantly consume what they have
if(activated())
{
this.lastPowerConsumption = this.power;
this.power = 0;
}
else
{
this.lastPowerConsumption = 0;
this.power = 0;
}
break;
case CMMsg.TYP_DEACTIVATE:
this.activate(false);
this.lastPowerConsumption = 0;
this.power = 0;
//TODO:what does the ship need to know?
break;
}
}
}
@Override
public boolean sameAs(Environmental E)
{
if(!(E instanceof StdShipShieldGenerator))
return false;
return super.sameAs(E);
}
}
