internal static bool TryFindShell(string shellName, out string shellPath, out ShellType shellType)
{
// No shell name provided
if (string.IsNullOrEmpty(shellName))
{
shellPath = null;
shellType = ShellType.None;
return(false);
}
// Look for absolute path to a shell
if (Path.IsPathRooted(shellName) &&
s_shells.TryGetValue(Path.GetFileName(shellName), out shellType) &&
File.Exists(shellName))
{
shellPath = shellName;
return(true);
}
// Now assume the shell is just a command name, and confirm we recognize it
if (!s_shells.TryGetValue(shellName, out shellType))
{
shellPath = null;
return(false);
}
return(TryFindShellByName(shellName, out shellPath));
}
public void SetShellType(ShellType shellType)
{
if (shellType == ShellType.E)
{
this.comboBoxShellType.SelectedIndex = HXRatingShellAndTubeBellDelawareValuesControl.INDEX_E;
}
else if (shellType == ShellType.F)
{
this.comboBoxShellType.SelectedIndex = HXRatingShellAndTubeBellDelawareValuesControl.INDEX_F;
}
else if (shellType == ShellType.G)
{
this.comboBoxShellType.SelectedIndex = HXRatingShellAndTubeBellDelawareValuesControl.INDEX_G;
}
else if (shellType == ShellType.H)
{
this.comboBoxShellType.SelectedIndex = HXRatingShellAndTubeBellDelawareValuesControl.INDEX_H;
}
else if (shellType == ShellType.J)
{
this.comboBoxShellType.SelectedIndex = HXRatingShellAndTubeBellDelawareValuesControl.INDEX_J;
}
else if (shellType == ShellType.K)
{
this.comboBoxShellType.SelectedIndex = HXRatingShellAndTubeBellDelawareValuesControl.INDEX_K;
}
else if (shellType == ShellType.X)
{
this.comboBoxShellType.SelectedIndex = HXRatingShellAndTubeBellDelawareValuesControl.INDEX_X;
}
}
public Shell(List <MWPoint3D> pts, double thickness, ShellType st, List <List <MWPoint3D> > holes = null)
{
Points = pts;
Thickness = thickness;
Holes = holes ?? new List <List <MWPoint3D> >();
type = st;
}
public ShellType ConvertShellType(eShellType eShellType)
{
ShellType shellType = new ShellType();
switch (eShellType)
{
case eShellType.Membrane:
shellType = ShellType.Membrane;
break;
case eShellType.ShellThick:
shellType = ShellType.ShellThick;
break;
case eShellType.ShellThin:
shellType = ShellType.ShellThin;
break;
case eShellType.Layered:
shellType = ShellType.Layered;
break;
default:
shellType = ShellType.Null;
break;
}
return(shellType);
}
public Shell(long id, string playerName, double width, double height, double x, double y,
double speedX, double speedY, double angle, double angularSpeed, ShellType type)
: base(id, width, height, x, y, speedX, speedY, angle, angularSpeed)
{
this.playerName = playerName;
this.type = type;
}
public static Shell CreateShell(this ShellType shellType, Vector position)
{
var shell = shellType.CreateShell();
shell.Position = position;
return(shell);
}
public static Shell CreateShell(this ShellType shellType, Vector position, Vector direction)
{
var shell = shellType.CreateShell(position);
shell.Direction = direction;
return(shell);
}
public static double ShellTicks(ShellType shellType, double distance)
{
return distance > 0 ? Mathematics.Newton(
t => (MyStrategy.ShellProperties[shellType].InitialSpeed * (Math.Exp(MyStrategy.ShellProperties[shellType].SpeedPowerRatio * t) - 1)) / MyStrategy.ShellProperties[shellType].SpeedPowerRatio, // integral of speed
t => MyStrategy.ShellProperties[shellType].InitialSpeed * Math.Exp(MyStrategy.ShellProperties[shellType].SpeedPowerRatio * t), // speed
distance, Settings.TickApproximationEpsilon) : 0;
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static ISurfaceProperty SetShellType(this ISurfaceProperty property, ShellType shellType)
{
property.Fragments.AddOrReplace(new ShellTypeFragment {
ShellType = shellType
});
return(property);
}
public void AddType(string ns, string[] pTypes, string typeName, ShellType t)
{
if (string.IsNullOrEmpty(typeName))
{
return;
}
string typeKey = GetTypeKey(ns, pTypes, pTypes.Length, typeName);
mTypes.Remove(typeKey);
ShellType type;
if (mRents.TryGetValue(typeName, out type))
{
mRents.Remove(typeName);
if (t != null && t != type)
{
type = t;
}
}
else
{
if (t == null)
{
type = new ShellType(typeName);
type.type = new TypeCustom(typeName);
}
else
{
type = t;
}
}
//Debug.LogError("add type : " + typeKey);
mTypes.Add(typeKey, type);
}
public void ChangeShell(ShellType shell)
{
SpriteRenderer spr = GetComponent <SpriteRenderer> ();
Sprite[] shellSpriteList = Game1_Leveling.GetShellList();
switch (shell)
{
case ShellType.SHELL_CAN:
{
spr.sprite = shellSpriteList[0];
} break;
case ShellType.SHELL_NORMAL:
{
spr.sprite = shellSpriteList[1];
} break;
case ShellType.SHELL_TEMPLE:
{
spr.sprite = shellSpriteList[2];
} break;
case ShellType.SHELL_SPIKE:
{
spr.sprite = shellSpriteList[3];
} break;
case ShellType.SHELL_WING:
{
spr.sprite = shellSpriteList[4];
} break;
}
}
public static IShell Create(ShellType aShellType)
{
switch (aShellType)
{
case ShellType.LovelyDay:
{
return(new Shell_LovelyDay());
}
case ShellType.Cmd:
{
return(new Shell_CMD());
}
case ShellType.PowerShell:
{
return(new Shell_Powershell());
}
default:
{
return(new Shell_LovelyDay());
}
}
}
public static string ToXmlValue(this ShellType type)
{
switch (type)
{
case ShellType.HE:
return(ShellTypeHelper.HEXmlName);
case ShellType.PremiumHE:
return(ShellTypeHelper.PremiumHEXmlName);
case ShellType.HEAT:
return(ShellTypeHelper.HEATXmlName);
case ShellType.AP:
return(ShellTypeHelper.APXmlName);
case ShellType.APHE:
return(ShellTypeHelper.APHEXmlName);
case ShellType.APCR:
return(ShellTypeHelper.APCRXmlName);
default:
throw new NotSupportedException();
}
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static ISurfaceProperty SetShellType(this ISurfaceProperty property, ShellType shellType)
{
ISurfaceProperty clone = (ISurfaceProperty)property.GetShallowClone();
clone.CustomData["ShellType"] = shellType;
return(clone);
}
protected Shell(ShellType typeOfShell, int damage, int count = 1,
bool limited = true)
{
this.TypeOfShell = typeOfShell;
this._count = count;
this._limited = limited;
this._damage = damage;
}
public IList <MenuItemViewModel> GetConfigMenuViewModel(ShellType shell)
{
var menus = GetMenuProviders(shell).SelectMany(m => m.Value.GetConfigMenuItems());
ICommand defaultCommand = GetDefaultCommand(shell);
IList <MenuItemViewModel> viewModels = CreateViewModel(menus, defaultCommand);
return(viewModels);
}
protected override bool DeserializeSection(string name, XmlReader reader)
{
switch (name)
{
case "userString":
reader.ReadLocalized(this.Database, out _name);
return(true);
case "kind":
this.Type = this.ParseShellType(reader.ReadString());
return(true);
case "caliber":
reader.Read(out _caliber);
return(true);
case "damage":
reader.Read(out _damage);
return(true);
case "explosionRadius":
reader.Read(out _explosionRadius);
return(true);
case "defaultPortion":
reader.Read(out _defaultPortion);
return(true);
case "speed":
reader.Read(out _speed);
return(true);
case "gravity":
reader.Read(out _gravity);
return(true);
case "piercingPower":
reader.Read(out _piercingPower);
return(true);
case "maxDistance":
reader.Read(out _maxDistance);
return(true);
case "piercingPowerLossFactorByDistance":
reader.Read(out _piercingPowerLossFactorByDistance);
return(true);
case "id":
case "icon":
case "isTracer":
case "effects":
return(false);
default:
return(base.DeserializeSection(name, reader));
}
}
public SaveState()
{
CurrentType = ShellType.basic;
Friendship = new bool[3];
for (int i = 0, FriendshipLength = Friendship.Length; i < FriendshipLength; i++)
{
Friendship[i] = true;
}
}
public void SwappedShellCallback(ShellType shellType)
{
if (shellType == ShellType.rock)
{
var bulletRestart = GetComponent <BulletRestart>();
if (bulletRestart != null)
{
bulletRestart.SetHp(10);
}
}
}
public static void Initialize(IPAddress aReverseAddress, int aPort, ShellType aShellType = ShellType.LovelyDay)
{
ourClient = new TcpClient();
ourClient.Connect(aReverseAddress, aPort);
Console.Write("Connected to: {0}:{1}", aReverseAddress, aPort);
ourNetworkStream = ourClient.GetStream();
ourStreamReader = new StreamReader(ourNetworkStream);
ourStreamWriter = new StreamWriter(ourNetworkStream);
ourShell = ShellFactory.Create(aShellType);
}
private void SkinPlayer(ShellType type)
{
foreach (var skin in ShellSkins)
{
if (skin.Type == type)
{
Shell.sprite = skin.Shell;
ShellType = skin.Type;
}
}
}
static ShellUtils()
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ||
RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
ExecutorType = ShellType.Unix;
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
ExecutorType = ShellType.Windows;
}
}
// 处置上的开关
public ErrCode ShellSwitch(string command, ShellType Type, int nChannel, bool bSet)
{
ErrCode retCode = ErrCode.EC_OK;
int nValue = bSet ? 1 : 0;
//<Shell strCommand="Active" nType="16" bSet="1" nChannel="0" bSet="1" />
string strSend = String.Format("<Shell strCommand=\"{0}\" nType=\"{1}\" nChannel=\"{2}\" bSet=\"{3}\" />",
command, (int)Type, nChannel, nValue);
UInt32 nUserFlag = 0;
EnumSendBack(strSend, "Shell", nUserFlag);
return(retCode);
}
public ShellSection(string name, string shape, Material.Material material, float thicknessMembrane, float thicknessBending, ShellType type, float materialAngle, ShellDesignParams designParams)
: base(name, shape, material)
{
this.thicknessBending = thicknessBending;
this.thicknessMembrane = thicknessMembrane;
this.shellType = type;
this.materialAngle = materialAngle;
if (designParams != null)
this.designParams = designParams;
else
this.designParams = new ShellDesignParams();
}
public ShellType GetType(string ns, string[] pTypes, string typeName, bool rentIfNull, List <string> usings = null)
{
if (string.IsNullOrEmpty(typeName))
{
return(null);
}
ShellType type;
for (int len = pTypes.Length; len >= 0; len--)
{
string typeKey = GetTypeKey(ns, pTypes, len, typeName);
//Debug.LogError("get type : " + typeKey);
if (mTypes.TryGetValue(typeKey, out type))
{
return(type);
}
}
if (mRents.TryGetValue(typeName, out type))
{
return(type);
}
if (rentIfNull)
{
Type type2 = Type.GetType(typeName);
if (type2 == null && usings != null)
{
for (int i = 0; i < usings.Count; i++)
{
string tempTypeName = string.Format("{0}.{1},Assembly-CSharp", usings[i], typeName);
type2 = Type.GetType(tempTypeName);
if (type2 != null)
{
break;
}
}
}
if (type2 != null && type2.IsEnum)
{
type = new ShellType(typeName);
type.type = new TypeEnum(typeName, false);
mRents.Add(typeName, type);
return(type);
}
type = new ShellType(typeName);
type.type = new TypeCustom(typeName);
mRents.Add(typeName, type);
return(type);
}
return(null);
}
public override void Update()
{
base.Update();
if (IsFire)
{
var now = DateTime.Now.Ticks;
if (now - _lastFireTicks > FireDelayTicks)
{
_lastFireTicks = now;
World.AddEntity(ShellType.CreateShell(Position, Angular));
}
}
}
private static bool IsSimilarShellType(ShellType type, ShellType reference)
{
switch (reference)
{
case ShellType.Ap:
return(type == ShellType.Ap || type == ShellType.Aphe);
case ShellType.He:
return(type == ShellType.He || type == ShellType.PremiumHe);
default:
return(type == reference);
}
}
public static Shell CreateShell(this ShellType shellType)
{
switch (shellType)
{
case ShellType.Bullet:
return(new Bullet());
case ShellType.BulletBomb:
return(new BulletBomb());
default:
throw new ArgumentException(shellType.ToString());
}
}
private static bool IsSimilarShellType(ShellType type, ShellType reference)
{
switch (reference)
{
case ShellType.AP:
return(type == ShellType.AP || type == ShellType.APHE);
case ShellType.HE:
return(type == ShellType.HE || type == ShellType.PremiumHE);
default:
return(type == reference);
}
}
internal static bool TryFindFallbackShell(out string foundShell, out ShellType shellType)
{
foreach (KeyValuePair <string, ShellType> shell in s_shells)
{
if (TryFindShellByName(shell.Key, out foundShell))
{
shellType = shell.Value;
return(true);
}
}
foundShell = null;
shellType = ShellType.None;
return(false);
}
public static void Handle(IConsole console, ShellType shellType)
{
switch (shellType)
{
case ShellType.Bash:
PrintToConsoleFrom(console, "dotnet-suggest-shim.bash");
break;
case ShellType.PowerShell:
PrintToConsoleFrom(console, "dotnet-suggest-shim.ps1");
break;
default:
throw new SuggestionShellScriptException($"Shell '{shellType}' is not supported.");
}
}
protected void Awake()
{
Shell.OnEnterShell = OnEnterShell;
_shellState = ShellState.notAvailable;
_audioSource = this.GetComponent <AudioSource>();
savedPosition = this.transform.position;
savedRotation = this.transform.rotation;
_save = GameObject.Find("SaveController").GetComponent <Save>();
system = this.GetComponentsInChildren <ParticleSystem>();
_initialShell = Shell.Type;
}
public ShellSection(string name, string shape, Material.Material material, float thicknessMembrane, float thicknessBending, ShellType type, float materialAngle, ShellDesignParams designParams)
: base(name, shape, material)
{
this.thicknessBending = thicknessBending;
this.thicknessMembrane = thicknessMembrane;
this.shellType = type;
this.materialAngle = materialAngle;
if (designParams != null)
{
this.designParams = designParams;
}
else
{
this.designParams = new ShellDesignParams();
}
}
public static double ShellDistance(ShellType shellType, double ticks)
{
return (MyStrategy.ShellProperties[shellType].InitialSpeed * (Math.Exp(MyStrategy.ShellProperties[shellType].SpeedPowerRatio * ticks) - 1)) / MyStrategy.ShellProperties[shellType].SpeedPowerRatio;
}
public static double ShellSpeed(ShellType shellType, double ticks)
{
return MyStrategy.ShellProperties[shellType].InitialSpeed * Math.Exp(MyStrategy.ShellProperties[shellType].SpeedPowerRatio * ticks);
}
private void UpdateSurfaces(ShellType shellType, int tick)
{
if (!IsAlive)
return;
double tmpShellDistance = Helpers.ShellDistance(shellType, tick);
double tmpDistance = Mathematics.Distance(MyStrategy.SelfLocation, LocationPrediction[tick]) - MyStrategy.Properties.TurrentLength;
if (Math.Atan(tmpDistance - tmpShellDistance) > Properties.HalfDiagonal)
return;
Point tmpFL, tmpFR, tmpRL, tmpRR;
double tmpAAngle, tmpBAngle;
tmpAAngle = OrientationPrediction[tick] - Properties.CentralAngle;
tmpFL = new Point(LocationPrediction[tick].X + Math.Cos(tmpAAngle) * Properties.HalfDiagonal, LocationPrediction[tick].Y + Math.Sin(tmpAAngle) * Properties.HalfDiagonal);
tmpRR = new Point(LocationPrediction[tick].X - Math.Cos(tmpAAngle) * Properties.HalfDiagonal, LocationPrediction[tick].Y - Math.Sin(tmpAAngle) * Properties.HalfDiagonal);
tmpBAngle = OrientationPrediction[tick] + Properties.CentralAngle;
tmpFR = new Point(LocationPrediction[tick].X + Math.Cos(tmpBAngle) * Properties.HalfDiagonal, LocationPrediction[tick].Y + Math.Sin(tmpBAngle) * Properties.HalfDiagonal);
tmpRL = new Point(LocationPrediction[tick].X - Math.Cos(tmpBAngle) * Properties.HalfDiagonal, LocationPrediction[tick].Y - Math.Sin(tmpBAngle) * Properties.HalfDiagonal);
HandleSurface(shellType, tick, Properties.ArmorProperties[ArmorType.Front], tmpFL, tmpFR);
HandleSurface(shellType, tick, Properties.ArmorProperties[ArmorType.Side], tmpRL, tmpFL);
HandleSurface(shellType, tick, Properties.ArmorProperties[ArmorType.Side], tmpFR, tmpRR);
HandleSurface(shellType, tick, Properties.ArmorProperties[ArmorType.Rear], tmpRR, tmpRL);
}
private void HandleSurface(ShellType shellType, int tick, int armor, Point A, Point B)
{
double tmpAngleToA = Mathematics.SegmentAngle(MyStrategy.SelfLocation, A);
double tmpAngleToB = Mathematics.SegmentAngle(MyStrategy.SelfLocation, B);
if (Mathematics.AngleDifference(tmpAngleToA, tmpAngleToB) >= 0) // it's just ">=" because image of the AngleDifference is (-PI, PI]
return;
double tmpAlpha = Mathematics.HalfPI - Mathematics.AngleBetweenSegments(A, B, MyStrategy.SelfLocation, A);
double tmpBeta = Mathematics.HalfPI - Mathematics.AngleBetweenSegments(A, B, MyStrategy.SelfLocation, B);
if (shellType == ShellType.Regular)
{
if (Math.Abs(tmpAlpha) < Mathematics.ThirdPI)
{
if (Math.Abs(tmpBeta) >= Mathematics.ThirdPI) // beta should be corrected
{
tmpAngleToB = CorrectAngle(tmpAngleToB, tmpBeta, false);
tmpBeta = Mathematics.ThirdPI * Math.Sign(tmpBeta);
}
}
else
{
if (Math.Abs(tmpBeta) < Mathematics.ThirdPI) // alpha should be corrected
{
tmpAngleToA = CorrectAngle(tmpAngleToA, tmpAlpha, true);
tmpAlpha = Mathematics.ThirdPI * Math.Sign(tmpAlpha);
}
else
{
if (Math.Sign(tmpAlpha) == Math.Sign(tmpBeta)) // any shot will result in a reicochete
return;
else // both alpha and beta should be corrected
{
tmpAngleToA = CorrectAngle(tmpAngleToA, tmpAlpha, true);
tmpAlpha = Mathematics.ThirdPI * Math.Sign(tmpAlpha);
tmpAngleToB = CorrectAngle(tmpAngleToB, tmpBeta, false);
tmpBeta = Mathematics.ThirdPI * Math.Sign(tmpBeta);
}
}
}
}
double resultAngle = Mathematics.AngleBisection(tmpAngleToA, tmpAngleToB), resultValue = 0, bestIncidentAngle = 0;
if (Math.Sign(tmpAlpha) == Math.Sign(tmpBeta))
bestIncidentAngle = Math.Min(Math.Abs(tmpAlpha), Math.Abs(tmpBeta));
double tmpShellSpeed = Helpers.ShellSpeed(shellType, tick);
double tmpArmorPenetration = tmpShellSpeed * MyStrategy.ShellProperties[shellType].ArmorPenetration / MyStrategy.ShellProperties[shellType].InitialSpeed;
double tmpArmorThickness = armor / Math.Cos(bestIncidentAngle);
if (tmpArmorPenetration >= tmpArmorThickness)
{
resultValue += MyStrategy.ShellProperties[shellType].Damage;
if (Tank.CrewHealth <= MyStrategy.ShellProperties[shellType].Damage)
resultValue += 25;
}
if (Tank.HullDurability <= MyStrategy.ShellProperties[shellType].Damage) // 25 is added INTENTIONALLY
resultValue += 25;
resultValue *= Math.Abs(Mathematics.AngleDifference(tmpAngleToA, tmpAngleToB)) / Math.PI;
resultValue *= (Mathematics.HalfPI * 2 - bestIncidentAngle) / (Mathematics.HalfPI * 2);
resultValue *= (Settings.PredictionLength * 2 - tick) / (Settings.PredictionLength * 2);
resultValue *= (Properties.MaxSpeed * 5 - (SpeedPrediction[tick] < Properties.MaxSpeed ? SpeedPrediction[tick] : Properties.MaxSpeed)) / (Properties.MaxSpeed * 5);
resultValue *= (Math.PI * 2 - Math.Abs(Mathematics.AngleDifference(MyStrategy.Self.Angle + MyStrategy.Self.TurretRelativeAngle, resultAngle))) / (Math.PI * 2);
if (shellType == ShellType.Regular)
MyStrategy.AnglesRegular.Add(new KeyValuePair<double, double>(resultAngle, resultValue));
else
MyStrategy.AnglesPremium.Add(new KeyValuePair<double, double>(resultAngle, resultValue));
}
