// Randomizes the type of die we are
// e.g. Brain, Shotgun, Footprints
public void Roll()
{
int roll = UnityEngine.Random.Range(1, 7);
if (roll < 4 && IsGreen)
{
m_Type = DieType.Brain;
return;
}
if (roll < 3 && IsYellow)
{
m_Type = DieType.Brain;
return;
}
if (roll < 2 && IsRed)
{
m_Type = DieType.Brain;
return;
}
if (roll < 5)
{
m_Type = DieType.Shotgun;
return;
}
m_Type = DieType.Footprints;
}
private void Populate_Charges(string DieType)
{
DieType dt = (DieType)System.Enum.Parse(typeof(DieType), DieType);
List <DieCharge> DC_List = parent.Charge_Dictionary[dt];
dataGridView1.Rows.Clear();
foreach (DieCharge DC in DC_List)
{
dataGridView1.Rows.Add(DC.Name, DC.GetFormula());
}
// Add empty row
dataGridView1.Rows.Add();
// Remove last delete button
foreach (DataGridViewRow row in dataGridView1.Rows)
{
DataGridViewCellStyle style = new DataGridViewCellStyle();
style.Padding = new Padding(0, 0, (row == dataGridView1.Rows[dataGridView1.Rows.Count - 1] ? 1000 : 0), 0);
style.BackColor = Color.FromArgb(76, 76, 76);
style.ForeColor = Color.White;
row.Cells[2].Style = style;
}
}
private void Save_Charges(string dieType_)
{
DieType dieType = (DieType)System.Enum.Parse(typeof(DieType), dieType_);
List <DieCharge> DC_List = new List <DieCharge>();
foreach (DataGridViewRow row in dataGridView1.Rows)
{
if (dataGridView1.Rows.IndexOf(row) < dataGridView1.Rows.Count)
{
try
{
DieCharge DC = new DieCharge(dieType);
DC.Name = row.Cells[0].Value.ToString();
DC.Formula = row.Cells[1].Value.ToString();
DC_List.Add(DC);
}
catch
{
}
}
}
parent.Charge_Dictionary[dieType] = DC_List;
}
public static int GetMedianValue(this DieType die)
{
switch (die)
{
case DieType.d3:
{ return(2); }
case DieType.d4:
{ return(3); }
case DieType.d6:
{ return(4); }
case DieType.d8:
{ return(5); }
case DieType.d10:
{ return(6); }
case DieType.d12:
{ return(7); }
case DieType.d20:
{ return(11); }
case DieType.d100:
{ return(51); }
default:
{ return(0); }
}
}
private string Get_Die_Prefix(DieType dt)
{
switch (dt)
{
case DieType.Solid:
return("DI");
case DieType.Hollow:
return("HO");
case DieType.Feeder:
return("FE");
case DieType.Bolster:
return("BO");
case DieType.Subbolster:
return("SB");
case DieType.Ring:
return("RI");
case DieType.Backer:
return("BA");
default:
return("DI");
}
}
public static int ToFacetCount(this DieType facetCount)
{
switch (facetCount)
{
case DieType.D4:
return(4);
case DieType.D6:
return(6);
case DieType.D8:
return(8);
case DieType.D10:
return(10);
case DieType.D12:
return(12);
case DieType.D20:
return(20);
case DieType.D100:
return(100);
default:
throw new ArgumentException("Unsupported DieType");
}
}
public int Roll(DieType dieSize, int count, int modifier)
{
var rng = new Random();
var roll = rng.Next((int)dieSize);
return((count * roll) + modifier);
}
public static int ToInt(this DieType dieType)
{
switch (dieType)
{
case DieType.D4:
return(4);
case DieType.D6:
return(6);
case DieType.D8:
return(8);
case DieType.D10:
return(10);
case DieType.D12:
return(12);
case DieType.D20:
return(20);
default:
throw new ArgumentOutOfRangeException(nameof(dieType), dieType, null);
}
}
public static int GetMaxValue(this DieType die)
{
switch (die)
{
case DieType.d3:
{ return(3); }
case DieType.d4:
{ return(4); }
case DieType.d6:
{ return(6); }
case DieType.d8:
{ return(8); }
case DieType.d10:
{ return(10); }
case DieType.d12:
{ return(12); }
case DieType.d20:
{ return(20); }
case DieType.d100:
{ return(100); }
default:
{ return(0); }
}
}
public DieCharge(DieType dt)
{
Dietype = dt;
Name = "";
Notes = "";
Quantity = 0;
Formula = "";
}
public void OnClassChanged(Class class_)
{
_dieType = CharacterSheetModel.GetHitDieTypeByClass(class_);
dieAvailable.text = _dieType.ToString();
// Invalidate any previous rolls
dieResult.text = InvalidDieResult;
}
public override void Die(DieType type = DieType.explode)
{
isAlive = false;
CharacterDeath death = new CharacterDeath {
};
EventAggregator.Publish(death);
}
private static void CheckRoll(DiceRollManager manager, DieType die, ushort upperBound)
{
//Act
var rolls = manager.RollDie(die, 1000);
//Assert
rolls.ForEach(roll => roll.RollValue.Should().BeInRange(0, upperBound));
}
/// <summary>
/// Returns the values from the number of specified dice, of the specified type. Results are sorted in the specified sort order.
/// </summary>
/// <param name="dieType">The type of die rolled</param>
/// <param name="numberOfDice">The number of dice to be rolled</param>
/// <param name="sortOrder">The order to sort the results in the returned array</param>
/// <returns>An array of integers representing the values of the dice rolls</returns>
public static int[] Roll(DieType dieType, int numberOfDice, SortOrder sortOrder)
{
int[] results = Roll(dieType, numberOfDice);
results = Sort(results, sortOrder);
return(results);
}
public PharoahDie NewDie(DieType dieType)
{
PharoahDie newDie = GameObject.Instantiate(prefabDice[(int)dieType]);
if (newDie.isSetDie()) {
newDie.MoveToSetDieArea();
}
return newDie;
}
public void AddHitPoints(DieType hitDieType, CharacterCoreAttribute statisticSource, int additionalHitPoints, bool enforceMinimumGain = true)
{
if (enforceMinimumGain)
{
additionalHitPoints = Math.Min(hitDieType.GetMedianValue(), additionalHitPoints);
}
this.StatisticBase = this.StatisticBase + additionalHitPoints + statisticSource.StatisticValue;
}
public static int GetRandomHPDieTotal(int level, DieType type)
{
int total = 0;
for (int i = 1; i <= level; i++)
total += GetRandomNumber(type);
return total;
}
private void AddRolls(DieType dieType, uint count, List <DiceRolls> diceRolls)
{
var rollRequest = new Dictionary <string, uint> {
{ dieType.ToString(), count }
};
var result = _manager.RollDice(rollRequest);
diceRolls.Add(result);
}
/// <summary>
/// Returns the value from a single rolled die of the specified type
/// </summary>
/// <param name="dieType">The type of die rolled</param>
/// <returns>An integer representing the value of a dice roll</returns>
public static int RollDie(DieType dieType)
{
int result = 0;
int max = (int)dieType;
result = GetRandomNumber(MinimumDieValue, max);
return(result);
}
public PharoahDie NewDie(DieType dieType)
{
PharoahDie newDie = GameObject.Instantiate(prefabDice[(int)dieType]);
if (newDie.isSetDie())
{
newDie.MoveToSetDieArea();
}
return(newDie);
}
public Weapon(string label, DieType damageDie, DamageTypes damageType, int dieNum, int rangeMin, int rangeMax, WeaponProperties[] weaponProps)
{
Label = label;
DamageDie = damageDie;
DamageType = damageType;
DieNum = dieNum;
RangeMin = rangeMin;
RangeMax = rangeMax;
WeaponProps = weaponProps;
}
public void ToFacetCount_Returns_Correct_Value(DieType die, int expected)
{
//Arrange
//Act
var actual = die.ToFacetCount();
//Assert
actual.Should().Be(expected);
}
public void ToDieType_Returns_Correct_Value(int facetCount, DieType expected)
{
//Arrange
//Act
var actual = facetCount.ToDieType();
//Assert
actual.Should().Be(expected);
}
// Return the next biggest
public baseCharges getDiaThk(double refDia, double refThk, DieType dt, bool isOddDimensions = true)
{
if (refDia * refThk == 0) // If either dimensions are based 0, call for quote
{
return(null);
}
baseCharges Ref_Base = parent.baseCharge_List.FirstOrDefault(x => x.Diameter * (isOddDimensions ? 1 : MetricFactor) >= refDia - (parent.isMetric ? parent.metricTolerance : 0) && x.Thickness * (isOddDimensions ? 1 : MetricFactor) >= refThk - (parent.isMetric ? parent.metricTolerance : 0) && x.Prefix == parent.Get_Die_Prefix(dt));
return(Ref_Base);
}
public static int RollDie(DieType die, int numberOfDie)
{
int value = 0;
for (int i = 0; i < numberOfDie; i++)
{
value += RollDie(die);
}
return value;
}
public ActionResult <List <Die> > GetSingle(DieType dieType, uint count)
{
if (count == 0)
{
return(BadRequest("Invalid Count"));
}
var result = _manager.RollDie(dieType, count);
return(result);
}
public static int RollDie(DieType die, int numberOfDie)
{
int value = 0;
for (int i = 0; i < numberOfDie; i++)
{
value += RollDie(die);
}
return(value);
}
/// <summary>
/// Returns the values from the number of specified dice, of the specified type
/// </summary>
/// <param name="dieType">The type of die rolled</param>
/// <param name="numberOfDice">The number of dice to be rolled</param>
/// <returns>An array of integers representing the values of the dice rolls</returns>
public static int[] Roll(DieType dieType, int numberOfDice)
{
int[] results = new int[numberOfDice];
for (int i = 0; i < numberOfDice; i++)
{
results[i] = RollDie(dieType);
}
return(results);
}
// load file
private void button1_Click(object sender, EventArgs e)
{
OpenFileDialog file = new OpenFileDialog();
file.Title = "Import charges file";
file.Multiselect = false;
file.DefaultExt = ".ecf";
file.Filter = "Exco Charges File (*.ecf)|*.ecf";
if (file.ShowDialog() == DialogResult.OK)
{
Grey_Out();
Application.DoEvents();
if (File.Exists(file.FileName))
{
List <string> Lines = new List <string>();
var text = File.ReadAllText(file.FileName).Trim();
text = parent.Decrypt_Line(text);
Lines = text.Split(new string[] { Environment.NewLine }, StringSplitOptions.None).ToList();// Save customers
// Create new instance
parent.Charge_Dictionary = new Dictionary <DieType, List <DieCharge> >();
foreach (string line in Lines)
{
if (line.StartsWith("DC"))
{
DieType dieType = (DieType)System.Enum.Parse(typeof(DieType), parent.Parse_Line_Information(line, "D"));
// Add entry if does not exist
if (!parent.Charge_Dictionary.ContainsKey(dieType))
{
parent.Charge_Dictionary.Add(dieType, new List <DieCharge>());
}
parent.Charge_Dictionary[dieType].Add(new DieCharge(dieType)
{
Name = parent.Parse_Line_Information(line, "N"),
Formula = parent.Parse_Line_Information(line, "F")
});
}
}
Populate_Charges(dieTypes.Text);
}
Grey_In();
}
}
public void SetDieType(DieType die)
{
dieType = die;
if (dieType == DieType.ATTACKER)
{
sprRend.color = Color.red;
}
else
{
sprRend.color = Color.white;
}
}
internal void SetTypeByDie(DieType dieType)
{
switch (dieType.ToString())
{
case "d8":
this.comboBox1.SelectedIndex = 0;
break;
case "d10":
this.comboBox1.SelectedIndex = 1;
break;
case "d12":
this.comboBox1.SelectedIndex = 2;
break;
}
}
internal void SetTypeByDie(DieType dieType)
{
switch (dieType.ToString())
{
case "d8":
this.comboBox1.SelectedIndex = 0;
break;
case "d10":
this.comboBox1.SelectedIndex = 1;
break;
case "d12":
this.comboBox1.SelectedIndex = 2;
break;
}
}
/// <summary>
/// Spawn in dead center (dialog convection)
/// </summary>
/// <param name="_parent"></param>
/// <param name="g"></param>
/// <param name="s"></param>
public Extra_Charges(Main _parent, List <DieCharge> ref_list, DieType dt, double BasePrice, Point g = new Point(), Size s = new Size())
{
Cur_DieType = dt;
Cur_BasePrice = BasePrice;
this.AutoScaleMode = AutoScaleMode.Font; InitializeComponent();
this.DoubleBuffered = true;
this.SetStyle(ControlStyles.ResizeRedraw, true);
parent = _parent;
Set_Form_Color(parent.Frame_Color);
Transferred_List = ref_list;
this.Location = new Point(g.X + 10, g.Y + 10);
// Create charge list
foreach (DieCharge dC in parent.Charge_Dictionary[dt])
{
Ref_List.Add(dC.Clone());
}
}
private void LoadDice(int numOfDice, DieType type)
{
for (int i = 0; i < numOfDice; i++)
{
if (type == DieType.Green)
{
_dice.Add(new GreenDie());
}
else if (type == DieType.Yellow)
{
_dice.Add(new YellowDie());
}
else if (type == DieType.Red)
{
_dice.Add(new RedDie());
}
}
}
public void AddType(long offset, DieType type)
{
types.Add (offset, type);
}
protected override TargetType CreateType()
{
reference = GetReference (type_offset);
if (reference == null) {
Console.WriteLine (
"UNKNOWN POINTER: {0}",
comp_unit.RealStartOffset + type_offset);
return null;
}
TargetType ref_type = reference.ResolveType ();
if (ref_type == null)
return null;
#if false
/* not sure we want this */
if (ref_type.TypeHandle == typeof (char))
return new NativeStringType (byte_size);
#endif
string name;
if (Name != null)
name = Name;
else
name = String.Format ("{0} []", ref_type.Name);
List<DieSubrangeType> list = new List<DieSubrangeType> ();
foreach (Die die in Children) {
DieSubrangeType subrange = die as DieSubrangeType;
if (subrange != null)
list.Add (subrange);
}
TargetArrayBounds bounds;
if (list.Count == 0)
bounds = TargetArrayBounds.MakeUnboundArray ();
else if ((list.Count == 1) && (list [0].UpperBound == null))
bounds = TargetArrayBounds.MakeUnboundArray ();
else if ((list.Count == 1) && ((list [0].LowerBound ?? 0) == 0))
bounds = TargetArrayBounds.MakeSimpleArray ((int) list [0].UpperBound + 1);
else {
int[] lower = new int [list.Count];
int[] upper = new int [list.Count];
for (int i = 0; i < list.Count; i++) {
lower [i] = list [i].LowerBound ?? 0;
upper [i] = (int) list [i].UpperBound;
}
bounds = TargetArrayBounds.MakeMultiArray (lower, upper);
}
return new NativeArrayType (
language, name, ref_type, bounds, byte_size);
}
protected override TargetType CreateType()
{
reference = GetReference (type_offset);
if (reference == null)
return null;
return reference.ResolveType ();
}
protected TargetType ResolveType(DieStructureType die_struct)
{
if ((TypeOffset == 0) || (Name == null))
return null;
if ((location == null) && !die_struct.IsUnion)
return null;
type_die = comp_unit.GetType (TypeOffset);
if (type_die == null)
return null;
if ((location != null) && !read_location ())
return null;
type = type_die.ResolveType ();
return type;
}
protected override TargetType CreateType()
{
TargetType ref_type;
if (type_offset == 0)
ref_type = language.VoidType;
else {
reference = GetReference (type_offset);
if (reference == null) {
Console.WriteLine (
"UNKNOWN POINTER: {0}",
comp_unit.RealStartOffset + type_offset);
return null;
}
ref_type = reference.ResolveType ();
if (ref_type == null)
return null;
}
TargetFundamentalType fundamental = ref_type as TargetFundamentalType;
if ((fundamental != null) && (fundamental.Name == "char"))
return new NativeStringType (language, byte_size);
TargetFunctionType func = ref_type as TargetFunctionType;
if (func != null)
return new NativeFunctionPointer (language, func);
string name;
if (Name != null)
name = Name;
else
name = NativePointerType.MakePointerName (ref_type);
return new NativePointerType (language, name, ref_type, byte_size);
}
protected override TargetType CreateType()
{
if (type_offset != 0) {
return_type = GetReference (type_offset);
if (return_type == null)
return null;
}
function_type = new NativeFunctionType (language);
return function_type;
}
public static int RollDie(DieType die)
{
return random.Next(0, (int) die) + 1;
}
public static int DieRoll(DieType dieType)
{
Random random = new Random();
return random.Next(0, (int)dieType);
}
/// <summary>
/// Simple Die factory that calls a generic roller method
/// using a base class reference.
/// </summary>
/// <param name="dieToRoll"></param>
/// <returns></returns>
private int[] RollDie(DieType dieToRoll)
{
DieBase dieBase = null;
switch (dieToRoll)
{
case DieType.D4:
dieBase = new D4();
break;
case DieType.D6:
dieBase = new D6();
break;
case DieType.D8:
dieBase = new D8();
break;
case DieType.D10:
dieBase = new D10();
break;
case DieType.D12:
dieBase = new D12();
break;
case DieType.D20:
dieBase = new D20();
break;
}
return GenericRoller(dieBase);
}
public GrimoireAbility(GrimoireLine line)
{
this.System = line.System;
this.Job = line.Job;
this.Name = line.Name;
switch (this.System)
{
case "Class":
//too complicated
this.SlotCost = ResolveClassSlotCosts(line.Job, line.APOrSlotCost, line.Keywords);
break;
case "Job":
if (line.APOrSlotCost <= 100)
{
this.SlotCost = 2;
}
else if (line.APOrSlotCost < 150)
{
this.SlotCost = 3;
}
else
{
//150 or more AP
this.SlotCost = 4;
}
break;
case "Crystal":
if (line.APOrSlotCost < 4)
{
this.SlotCost = 2;
}
else if (line.APOrSlotCost == 4)
{
this.SlotCost = 3;
}
else
{
//5 or more slots
this.SlotCost = 4;
}
break;
}
try
{
this.AbilityType = (AbilityType)Enum.Parse(typeof(AbilityType), line.Type);
}
catch
{
this.AbilityType = AbilityType.Support;
}
this.Delay = line.Delay;
this.Floor = line.Floor;
this.MP = line.MP;
this.MPPerTier = line.MPPerTier;
this.CT = line.CT;
this.CoS = line.CoS;
try
{
this.Target = (TargetType)Enum.Parse(typeof(TargetType), line.Target);
}
catch
{
this.Target = TargetType.Null;
}
this.AttackType = AttackType.Null;
if (line.Stat == "ATK") this.AttackType = AttackType.Physical;
if (line.Stat == "MAG") this.AttackType = AttackType.Magical;
if (this.AttackType == AttackType.Null)
{
if (line.Keywords.Contains("Magic"))
{
this.AttackType = AttackType.MagicalEffect;
}
else if(line.Keywords.Contains("Technique"))
{
this.AttackType = AttackType.PhysicalEffect;
}
}
this.Power = line.Power;
this.PowerPerTier = line.PowerPerTier;
this.Dice = line.Dice;
this.DicePerTier = line.DicePerTier;
string buildDieType = "d" + line.DieType.ToString();
try
{
this.DieType = (DieType)Enum.Parse(typeof(DieType), buildDieType);
}
catch
{
this.DieType = DieType.Null;
}
this.Multiplier = line.Multiplier;
this.Notes = line.Notes;
List<String> keywordsBroken = line.Keywords.Split(',').ToList<String>();
Regex rgx = new Regex("[^a-zA-Z:]");
this.Element = Element.Null;
foreach (String key in keywordsBroken)
{
//do preprocessing to mung Elemental, Status, and Effect keywords
String toAdd = rgx.Replace(key, "");
if (key.Contains("Elemental"))
{
//split at colon, element will be in split[1]
string[] parts = key.Split(':');
toAdd = "Elemental";
try
{
this.Element = (Element)Enum.Parse(typeof(Element), parts[1]);
}
catch
{
this.Element = Element.Null;
}
}
if (key.Contains("Status") || key.Contains("Effect"))
{
toAdd = "StatusEffect";
}
if (key.Contains("Enhancement"))
{
toAdd = "Enhancement";
}
try
{
this.Keywords.Add((Keyword)Enum.Parse(typeof(Keyword), toAdd));
}
catch
{
//couldn't recognise the keyword, do nothing.
Console.WriteLine("Could not recognise keyword " + toAdd);
}
}
}
public static short GetRandomNumber(DieType die)
{
return (short)rnd.Next(1, (int)die + 1);
}
protected override TargetType CreateType()
{
reference = GetReference (type_offset);
if (reference == null)
return null;
type = new NativeTypeAlias (language, Name, reference.Name);
return type;
}
protected void AddType(DieType type)
{
bfd.NativeLanguage.AddType (type);
}
private int GetIndexForType(DieType type)
{
int count = 0;
foreach (string name in Enum.GetNames(typeof(DieType)))
{
if (name == type.ToString())
return count;
count += 1;
}
return -1;
}
public static int RollDie(DieType die)
{
return Random.Range(0, (int)die) + 1;
}
protected override void ProcessAttribute(Attribute attribute)
{
switch (attribute.DwarfAttribute) {
case DwarfAttribute.name:
name = (string) attribute.Data;
break;
case DwarfAttribute.specification:
specification = comp_unit.GetType ((long) attribute.Data);
break;
}
}
