public bool GetAmmo(Ship ship, Map map, out LaserType a, out RocketType r, out HellstormType h)
{
a = ((this.DefaultLaser == LaserType.Default) ? LaserType.LCB_10 : this.DefaultLaser);
r = this.DefaultRocket;
h = this.DefaultHellstorm;
if (!ship.IsNpc && !map.IsGG)
{
return(false);
}
SelectedNpcModel model = this.GetModel(ship, map, null, 0);
if (model == null)
{
if (!map.IsGG)
{
return(false);
}
}
else
{
a = ((model.Laser == LaserType.Default) ? a : model.Laser);
r = ((model.Rocket == RocketType.Default) ? r : model.Rocket);
h = ((model.Hellstorm == HellstormType.Default) ? h : model.Hellstorm);
bool flag;
if (map.method_8(ship, out flag) && model.GgCornerLaser != LaserType.Default)
{
a = model.GgCornerLaser;
}
else if (model.UseSab && ship.Shield >= 2000 && map.Hero.ShieldPercentage <= (float)this.MinSabShield && map.Hero.method_21("ammunition_laser_sab-50") > 100.0 && map.Hero.Formation != GEnum4.Moth)
{
a = LaserType.SAB_50;
}
}
return(true);
}
public static Dictionary <GameObject, LaserHit> GetCache(LaserType type)
{
if (!Cache.ContainsKey(type))
{
Cache.Add(type, new Dictionary <GameObject, LaserHit>());
}
return(Cache[type]);
}
/// <summary>
/// Loads XML config file.
/// </summary>
public void LoadConfig()
{
string path = _configPath;
try
{
if (!File.Exists(path))
{
throw new FileNotFoundException("Unable to load scenario. File not found.", path);
}
XDocument xDocument = XDocument.Load(path);
if (xDocument.Root == null)
{
throw new NullReferenceException("Unable to load config. Root of XML file is empty.");
}
XElement sound = xDocument.Root.Element("Sound");
if (sound == null)
{
throw new NullReferenceException("Unable to find Sound element in config.");
}
foreach (XElement node in sound.Elements())
{
float f;
if (!float.TryParse(node.Value, out f))
{
throw new Exception("Unable to parse value to float.");
}
SetVolume(node.Name.LocalName, f);
}
XElement xElement = xDocument.Root.Element("LaserType");
if (xElement != null)
{
string laser = xElement.Value;
if (!Enum.IsDefined(typeof(LaserType), laser))
{
throw new ArgumentOutOfRangeException(
string.Format("Unable to cast {0} to LaserType.", laser));
}
LaserType laserType = (LaserType)Enum.Parse(typeof(LaserType), laser);
_dropdown.Select((int)laserType);
MainSettings.Laser = laserType;
}
}
catch (Exception e)
{
Debug.LogWarning("Unable to parse config file: " + e.Message + "\n Loading configuration defaults...");
AudioSettings.LoadDefaults();
}
}
// reset to the presumed Peripheral defaults
void reset()
{
type = LaserType.NORMAL;
mode = LaserMode.MANUAL;
enabled = false;
watchdogSec = 10;
laserDelayMS = 500;
dump();
}
private float GetLaserThickness(LaserType laserType)
{
switch (laserType)
{
case LaserType.Always:
return(LaserThickness);
case LaserType.Never:
return(0);
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Adds a new laser to the entityManager.
/// </summary>
/// <param name="type">Het type laser</param>
/// <param name="position">De positie van de laser</param>
/// <param name="rotation">De richting/rotatie van de laser</param>
public void SpawnLaser(LaserType type, Vector2 position, float rotation)
{
Laser laser = null;
switch (type)
{
case LaserType.LIGHT: laser = new LightLaser(position, rotation); break;
case LaserType.MEDIUM: laser = new MediumLaser(position, rotation); break;
case LaserType.STRONG: laser = new HeavyLaser(position, rotation); break;
}
_entityManager.AddEntity(laser);
}
public void ChangeType(LaserType type)
{
switch (type)
{
case LaserType.ShipLaser:
spriteRenderer.sprite = ShipLaserSprite;
break;
case LaserType.EnemyLaser:
spriteRenderer.sprite = EnemyLaserSprite;
break;
default:
break;
}
}
public void DrawLaserPoint(LaserType laserType, DrawingContext dc, System.Windows.Point point)
{
dc.DrawRectangle(System.Windows.Media.Brushes.Transparent, null, new Rect(0, 0, imgBoard.Width, imgBoard.Height));
if (point.X == 0 && point.Y == 0)
{
// Erase(Fake draw... zzz)
dc.DrawEllipse(System.Windows.Media.Brushes.Transparent,
new System.Windows.Media.Pen(System.Windows.Media.Brushes.Transparent, 1),
new System.Windows.Point(0, 0), 0, 0);
}
else
{
// Draw
dc.DrawEllipse(System.Windows.Media.Brushes.Red, redPen, new System.Windows.Point(point.X, point.Y), 2, 2);
}
}
public void DrawLaserPoint(LaserType laserType, DrawingContext dc, System.Windows.Point point)
{
dc.DrawRectangle(System.Windows.Media.Brushes.Transparent, null, new Rect(0, 0, imgBoard.Width, imgBoard.Height));
if (point.X == 0 && point.Y == 0)
{
// Erase(Fake draw... zzz)
dc.DrawEllipse(System.Windows.Media.Brushes.Transparent,
new System.Windows.Media.Pen(System.Windows.Media.Brushes.Transparent, 1),
new System.Windows.Point(0, 0), 0, 0);
}
else
{
// Draw
dc.DrawEllipse(System.Windows.Media.Brushes.Red, redPen, new System.Windows.Point(point.X, point.Y), 2, 2);
}
}
void LateUpdate()
{
if (hideAll)
{
return;
}
if (!target)
{
currentLaserType = LaserType.Straight;
straightLaser.enabled = true;
}
if (currentLaserType == LaserType.Straight)
{
return;
}
}
public void ChangeHand (bool isLeftHand, LaserType newType, Dictionary<LaserType, Color> colors) {
LaserType oldType = (isLeftHand ? leftHand : rightHand);
if (newType != oldType) {
Transform handTransform = transform.Find (isLeftHand ? "LeftHand" : "RightHand");
ChangeImage (handTransform.GetComponentInChildren<Image> (), colors [newType]);
if (isLeftHand) {
if (rightHand == newType) {
ChangeImage (transform.Find ("RightHand").GetComponentInChildren<Image> (), colors [oldType]);
rightHand = oldType;
}
leftHand = newType;
} else {
if (leftHand == newType) {
ChangeImage (transform.Find ("LeftHand").GetComponentInChildren<Image> (), colors [oldType]);
leftHand = oldType;
}
rightHand = newType;
}
}
}
public void SetLaserByType(LaserType type)
{
switch (type)
{
case LaserType.SaturnFixed:
this.picturebox.Laser = fixedLaser;
break;
case LaserType.SaturnActive:
this.picturebox.Laser = activeLaser;
break;
case LaserType.Alignment:
this.picturebox.Laser = alignLaser;
break;
default:
this.picturebox.Laser = fixedLaser;
break;
}
}
public Laser(Vector2 initialPosition, Vector2 targetPosition,
InflictDamage inflictDamageDelegate, LaserType laserType = LaserType.Interceptor)
: base(initialPosition, Allegiance.Neutral)
{
mLifeTime = int.MaxValue;
Position = initialPosition;
mStartPosition = initialPosition;
mTargetPosition = targetPosition;
mLaserType = laserType;
mInflictDamageDelegate = inflictDamageDelegate;
// DeathStar-Laser-Zeug
if (laserType == LaserType.DeathStarBeam)
{
mLifeTime = 3;
/* Vector2 normalizedDirVector = targetPosition - initialPosition;
normalizedDirVector.Normalize();
Position = initialPosition + normalizedDirVector * Global.DeathStarCollisionRadius;
mLength = (int)(Position - (targetPosition - normalizedDirVector * Global.mPlanetRadius[PlanetSize.Medium])).Length(); */
}
mLaserMovement = new LaserMovement(this, targetPosition, MovementSpeed);
}
public Laser CreateLaser(Vector2 start, Vector2 end, InflictDamage inflictDamageDeligate, LaserType type)
{
var laser = new Laser(start, end, inflictDamageDeligate, type);
return laser;
}
//sets the laser type
public void setLaserType(LaserType newType)
{
laserType = newType;
}
public static string smethod_1(LaserType laserType_0)
{
return(laserType_0.smethod_0());
}
// Parse and validate a 6-byte payload received from Peripheral by Central.
//
// If any part of the payload does not pass validation, the entire payload
// is rejected and application state is unchanged.
public bool parse(byte[] data)
{
if (data.Length != 6)
{
logger.error($"rejecting LaserState with invalid payload length {data.Length}");
return(false);
}
////////////////////////////////////////////////////////////////////
// Laser Type
////////////////////////////////////////////////////////////////////
LaserType newType = LaserType.NORMAL;
byte value = data[0];
if (value < (byte)LaserType.MAX_LASER_TYPES)
{
newType = (LaserType)value;
}
else
{
logger.error($"rejecting LaserState with invalid LaserType {value}");
return(false);
}
////////////////////////////////////////////////////////////////////
// Laser Mode
////////////////////////////////////////////////////////////////////
LaserMode newMode = LaserMode.MANUAL;
value = data[1];
if (value < (byte)LaserMode.MAX_LASER_MODES)
{
newMode = (LaserMode)value;
}
else
{
logger.error($"rejecting LaserState with invalid LaserMode 0x{value:x2}");
return(false);
}
////////////////////////////////////////////////////////////////////
// Laser Enabled
////////////////////////////////////////////////////////////////////
bool newEnabled = false;
value = data[2];
if (value < 0x02)
{
newEnabled = value == 0x01;
}
else
{
logger.error($"rejecting LaserState with invalid LaserEnabled 0x{value:x2}");
return(false);
}
////////////////////////////////////////////////////////////////////
// Laser Watchdog
////////////////////////////////////////////////////////////////////
byte newWatchdog = 0;
value = data[3];
if (value < 0xff)
{
newWatchdog = value;
}
else
{
logger.error($"rejecting LaserState with invalid LaserWatchdog 0x{value:x2}");
return(false);
}
////////////////////////////////////////////////////////////////////
// Laser Delay
////////////////////////////////////////////////////////////////////
ushort newLaserDelayMS = (ushort)((data[4] << 8) | data[5]);
////////////////////////////////////////////////////////////////////
// all fields validated, accept new values
////////////////////////////////////////////////////////////////////
type = newType;
enabled = newEnabled;
watchdogSec = newWatchdog;
laserDelayMS = newLaserDelayMS;
if (!SW_RAMAN_MODE)
{
mode = newMode;
}
dump();
return(true);
}
public ExpManager()
{
LaserType = LaserType.SaturnFixed;
}
private void SetLaserType(IAttacker owner)
{
if (owner is Interceptor) mLaserType = LaserType.Interceptor;
else if (owner is Predator) mLaserType = LaserType.Predator;
else if (owner is Defender) mLaserType = LaserType.Defender;
else if (owner is DeathStar) mLaserType = LaserType.DeathStarLaser;
else mLaserType = LaserType.Interceptor;
}
public void setTypeOfLaser(LaserType newType)
{
lt = newType;
}
private int LaserTypeEnumToInt (LaserType laserType) {
switch (laserType) {
case LaserType.None:
return 0;
case LaserType.Water:
return 1;
case LaserType.Force:
return 2;
}
}
// Temp
public float SetLaserInfo(LaserType type, float speed = 1.0f, float spriteGap = 0)
{
if (this == null)
{
return(-1);
}
activeLaserFront = true;
laserFrontSpeed = laserEndSpeed = speed * 2 * PublicValueStorage.Instance.GetAddSpeedRivisionValue();
laserEndLaunchDelay = speed;
lineCollider = line.GetComponent <BoxCollider2D>();
float frontWidth = front.GetComponent <SpriteRenderer>().bounds.extents.y * 2.0f;
lineCollider.transform.position = front.transform.position;
lineCollider.size = new Vector2(frontWidth, frontWidth);
laserType = type;
switch (type)
{
case LaserType.NormalLaser:
this.tag = "NormalLaser";
//Debug.Log(this.transform.position + "//" + playerPos);
laserFrontVector = laserEndVector = oPCurves.SeekDirection(this.transform.position, playerPos);
laserEndLaunchDelay *= 0.5f;
line.SetPosition(0, this.transform.position);
line.SetPosition(line.positionCount - 1, this.transform.position);
break;
case LaserType.PlayerLaser:
this.tag = "PlayerReflectLaser";
endInitPosition = end.transform.position;
//Debug.Log(this.transform.position + "//" + playerPos);
laserFrontSpeed = laserEndSpeed = speed * 3.0f;
laserEndLaunchDelay /= 3.0f;
GameObject target = PublicValueStorage.Instance.GetBossChildForAttacked();
if (target == null)
{
//Debug.Log("is NULL");
Vector3 tempDest = new Vector3(0, 10, 0);
tempDest.x += Random.Range(-5.0f, 5.0f);
laserFrontVector = laserEndVector = oPCurves.SeekDirection(this.transform.position, tempDest);
}
else
{
laserFrontVector = laserEndVector = oPCurves.SeekDirection(this.transform.position, target.transform.position);
}
//StartCoroutine(ControllerPlayerLaser());
line.SetPosition(0, this.transform.position);
line.SetPosition(line.positionCount - 1, this.transform.position);
break;
case LaserType.CircleLaser:
this.tag = "CircleLaser";
line.enabled = false;
end.gameObject.SetActive(false);
circleLaserScale = 1.5f * PublicValueStorage.Instance.GetAddSpeedRivisionValue();
circleLaserScale = (circleLaserScale >= 2.5f) ? 2.5f : circleLaserScale;
laserFrontVector = laserEndVector = oPCurves.SeekDirection(this.transform.position, playerPos);
activeLaserFront = false;
activeCircleLaser = true;
break;
case LaserType.ReflectLaser:
return(-1);
case LaserType.LaserNo5:
this.tag = "LaserNo5Laser";
Vector2 newDestination = playerPos;
newDestination.x += Random.Range(spriteGap * (-1.2f), spriteGap * 1.2f);
laserFrontVector = laserEndVector = oPCurves.SeekDirection(this.transform.position, newDestination);
line.SetPosition(0, this.transform.position);
line.SetPosition(line.positionCount - 1, this.transform.position);
laserEndLaunchDelay /= speed * 2.5f;
laserFrontSpeed = laserEndSpeed = speed * 0.5f;
break;
default:
//Debug.Log(this.GetType().ToString() + " is wrong");
return(-1);
}
for (int i = 0; i < this.transform.childCount; i++)
{
this.transform.GetChild(i).tag = this.tag;
}
return(laserEndLaunchDelay);
}
// Use this for initialization
void Start () {
leftHand = LaserType.None;
leftHand = LaserType.None;
}
private void InventoryItemRightClickMethod (LaserType type) {
equipmentBarPanel.GetComponent<EquipmentBar> ().ChangeHand (false, type, laserColors);
}
/// <summary>
/// Sends a laser from initial Position to the target Position
/// </summary>
/// <param name="initialPosition"></param>
/// <param name="targetPosition"></param>
/// <param name="inflictDamageDelegate"> </param>
/// <param name="type"></param>
public Laser FireLaser(Vector2 initialPosition, Vector2 targetPosition, InflictDamage inflictDamageDelegate, LaserType type)
{
var laser = mGameObjectFactory.CreateLaser(initialPosition, targetPosition, inflictDamageDelegate, type);
AddUnit(laser);
return laser;
}
