public void RefreshPrice(decimal vat, UnitKind unit, decimal quantityPerUnit)
{
switch (unit)
{
case UnitKind.ml:
WholeSalePrice = Math.Round(WholeSalePricePerUnit / quantityPerUnit * 1000, DIGITS_COUNT, MidpointRounding.AwayFromZero);
break;
case UnitKind.l:
WholeSalePrice = Math.Round(WholeSalePricePerUnit / quantityPerUnit, DIGITS_COUNT, MidpointRounding.AwayFromZero);
break;
case UnitKind.g:
WholeSalePrice = Math.Round(WholeSalePricePerUnit / quantityPerUnit * 1000, DIGITS_COUNT, MidpointRounding.AwayFromZero);
break;
case UnitKind.kg:
WholeSalePrice = Math.Round(WholeSalePricePerUnit / quantityPerUnit, DIGITS_COUNT, MidpointRounding.AwayFromZero);
break;
default:
WholeSalePrice = WholeSalePricePerUnit;
break;
}
}
/// <summary>
/// Creates a map unit
/// </summary>
/// <param name="map"></param>
/// <param name="unit"></param>
/// <param name="movementOffset"></param>
internal MapUnit(Map map, Unit unit, Vector movementOffset)
{
Map = map;
Kind = unit.Kind;
RadiusInternal = unit.Radius;
Name = unit.Name;
mobility = unit.Mobility;
isOrbiting = unit.IsOrbiting;
isMasking = unit.IsMasking;
isSolid = unit.IsSolid;
gravity = unit.Gravity;
PositionInternal = unit.Position;
MovementInternal = unit.Movement + movementOffset;
if (isOrbiting)
{
OrbitingCenter = unit.OrbitingCenter;
orbitingList = new List <UnitOrbitingState>();
foreach (var orbitingState in unit.OrbitingList)
{
orbitingList.Add(new UnitOrbitingState(orbitingState));
}
}
AgeInternal = 0;
}
private Stack <GameObject> initPool(int poolSize, UnitKind unitKind)
{
GameObject prefab = null;
switch (unitKind)
{
case UnitKind.Policy:
prefab = policyPrefab;
break;
case UnitKind.Fireman:
prefab = firemanPrefab;
break;
case UnitKind.Doctor:
prefab = doctorPrefab;
break;
}
Stack <GameObject> pool = new Stack <GameObject>(poolSize);
for (int i = 0; i < poolSize; i++)
{
GameObject go = Instantiate(prefab);
go.transform.SetParent(transform);
go.SetActive(false);
go.GetComponent <Unit>().recall += recall;
pool.Push(go);
}
return(pool);
}
public static ShortTimeSpan FromSeconds(double seconds)
{
var s = seconds;
UnitKind unit = UnitKind.Seconds;
if (s < 1)
{
s = seconds * 1e3;
unit = UnitKind.Milliseconds;
if (s < 1)
{
s = seconds * 1e6;
unit = UnitKind.Microseconds;
if (s < 1)
{
s = seconds * 1e9;
unit = UnitKind.Nanoseconds;
if (s < 1) // treat < 0 ns as 0 s.
{
return(default(ShortTimeSpan));
}
}
}
}
return(new ShortTimeSpan {
unit = unit, Value = Math.Round(s, 3)
});
}
public void SetConditioning(ConditioningKind conditioning, decimal quantity,
UnitKind unit = UnitKind.NotSpecified)
{
if (conditioning == ConditioningKind.Not_Specified)
{
throw SheaftException.Validation("Le conditionnement est requis.");
}
if (conditioning != ConditioningKind.Bulk)
{
unit = UnitKind.NotSpecified;
}
if (conditioning == ConditioningKind.Bouquet || conditioning == ConditioningKind.Bunch)
{
quantity = 1;
}
if (quantity <= 0)
{
throw SheaftException.Validation("La quantité par conditionnement ne peut pas être inférieure à 0.");
}
if (conditioning == ConditioningKind.Bulk && unit == UnitKind.NotSpecified)
{
throw SheaftException.Validation("L'unité du type de conditionnement est requis.");
}
Conditioning = conditioning;
QuantityPerUnit = quantity;
Unit = unit;
RefreshPrices();
}
/// <summary>
/// 栄養素クラスを作成する
/// </summary>
/// <param name="value">栄養素</param>
/// <param name="unitKind">単位の種類</param>
/// <returns>栄養素クラス</returns>
public static Nutrient Parse(string value, UnitKind unitKind)
{
double nutrientValue = 0.0;
bool isEstimateValue = false;
string nutrientValueStr = value.Trim('\"');
// 値が最小単位以下(Tr)の場合NaNに設定
if (nutrientValueStr == "Tr" || nutrientValueStr == "(Tr)" || nutrientValueStr == "-" || nutrientValueStr == "*")
{
//nutrientValue = Double.NaN;
nutrientValue = 0.0d;
isEstimateValue = nutrientValueStr.Contains("(");
}
// カッコがあれば推定値とみなす
else if (nutrientValueStr.Contains("("))
{
nutrientValue = double.Parse(nutrientValueStr.Trim('(', ')'));
isEstimateValue = true;
}
// 数値ならばdouble型にParse
else
{
nutrientValue = Double.Parse(value.Trim('(', ')'));
}
return(new Nutrient(nutrientValue, unitKind, isEstimateValue));
}
/// <summary>
/// Constructor to clone a map unit
/// </summary>
/// <param name="mapUnit"></param>
protected MapUnit(MapUnit mapUnit)
{
Map = mapUnit.Map;
Kind = mapUnit.Kind;
RadiusInternal = mapUnit.Radius;
Name = mapUnit.Name;
mobility = mapUnit.Mobility;
isOrbiting = mapUnit.IsOrbiting;
isMasking = mapUnit.IsMasking;
isSolid = mapUnit.IsSolid;
gravity = mapUnit.gravity;
PositionInternal = new Vector(mapUnit.PositionInternal);
MovementInternal = new Vector(mapUnit.MovementInternal);
if (isOrbiting)
{
OrbitingCenter = mapUnit.OrbitingCenter;
orbitingList = new List <UnitOrbitingState>();
foreach (var orbitingState in mapUnit.orbitingList)
{
orbitingList.Add(new UnitOrbitingState(orbitingState));
}
}
AgeInternal = 0;
}
public Report(string name, DateTimeOffset startTime, DateTimeOffset?stopTime, UnitKind unit, IEnumerable <Group> groups, string defaultGroupName)
{
Name = name;
StartTime = startTime;
StopTime = (stopTime == null) ? DateTimeOffset.Now : stopTime.Value;
Unit = unit;
Groups = groups;
DefaultGroupName = defaultGroupName;
}
/// <summary>
/// Determines whether the specified unit can be converted to a specific target unit.
/// </summary>
/// <param name="source">The source unit.</param>
/// <param name="target">The target unit.</param>
/// <returns></returns>
public static bool CanConvert(UnitKind source, UnitKind target)
{
if (!Converters.ContainsKey(source))
{
throw new KeyNotFoundException(nameof(source));
}
return(Converters[source].ContainsKey(target));
}
// 매개변수로 받아온 스탯 클래스를 기반으로 Unit을 생성(활성화)
public void CreateUnit(UnitKind unitKind)
{
Unit unit = units[unitKind].GetObject();
SpriteRenderer sr = unit.gameObject.GetComponent <SpriteRenderer>();
sr.sortingOrder = sortingOrder++;
unit.gameObject.SetActive(true);
}
/// <summary>
/// Converts a value of a specific unit to the specified target unit.
/// </summary>
/// <param name="source">The source unit value.</param>
/// <param name="targetUnit">The target unit.</param>
/// <param name="targetPrefix">The target prefix.</param>
/// <returns></returns>
public static decimal Calculate(UnitValue source, UnitKind targetUnit, PrefixKind targetPrefix = PrefixKind.None)
{
if (!CanConvert(source.Unit, targetUnit))
{
throw new Exception("The specified source unit cannot be converted to the target unit.");
}
Prefix prefix = Prefixes
.FirstOrDefault(x => x.Kind == targetPrefix) != null
? Prefixes.First(x => x.Kind == targetPrefix)
: Prefixes.First(x => x.Kind == PrefixKind.None);
return((decimal)Converters[source.Unit][targetUnit](source.GetValue()) / (decimal)prefix.Multiplier);
}
internal static string Symbol(this UnitKind kind)
{
return(kind switch
{
UnitKind.Second => "s",
UnitKind.Minute => "min",
UnitKind.Hour => "h",
UnitKind.Day => "day",
UnitKind.Metre => "m",
UnitKind.AstronomicalUnit => "au",
UnitKind.AngelDegree => "deg",
UnitKind.AngleMinute => "min",
UnitKind.AngleSecond => "sec",
UnitKind.Hectare => "ha",
UnitKind.Litre => "l",
UnitKind.Gram => "g",
UnitKind.Tonne => "t",
UnitKind.Dalton => "Da",
UnitKind.Ampere => "A",
UnitKind.ElectronVolt => "eV",
UnitKind.Kelvin => "K",
UnitKind.Celsius => "degC",
UnitKind.Mole => "mol",
UnitKind.Candela => "cd",
UnitKind.Decibel => "dB",
UnitKind.Bel => "B",
UnitKind.Neper => "Np",
UnitKind.Radian => "rad",
UnitKind.Steradian => "sr",
UnitKind.Hertz => "Hz",
UnitKind.Newton => "N",
UnitKind.Pascal => "Pa",
UnitKind.Joule => "J",
UnitKind.Watt => "W",
UnitKind.Coulomb => "C",
UnitKind.Volt => "V",
UnitKind.Farad => "F",
UnitKind.Ohm => "Ω",
UnitKind.Siemens => "S",
UnitKind.Weber => "Wb",
UnitKind.Tesla => "T",
UnitKind.Henry => "H",
UnitKind.Lumen => "lm",
UnitKind.Lux => "lx",
UnitKind.Becquerel => "Bq",
UnitKind.Gray => "Gy",
UnitKind.Sievert => "Sv",
UnitKind.Katal => "kat",
_ => "INVALID"
});
static string getUnitString(UnitKind unit)
{
switch (unit)
{
case UnitKind.Microseconds:
return("us"); // "μs" support this notation at a later time.
case UnitKind.Milliseconds:
return("ms");
case UnitKind.Nanoseconds:
return("ns");
default:
return("s");
}
}
/// <summary>
/// Optimized ctor for own map units
/// </summary>
/// <param name="map"></param>
/// <param name="kind"></param>
/// <param name="radius"></param>
/// <param name="name"></param>
/// <param name="mobility"></param>
/// <param name="isOrbiting"></param>
/// <param name="isMasking"></param>
/// <param name="isSolid"></param>
/// <param name="gravity"></param>
/// <param name="position"></param>
/// <param name="movement"></param>
/// <param name="movementOffset"></param>
/// <param name="orbitingCenter"></param>
/// <param name="orbitingList"></param>
internal MapUnit(Map map,
UnitKind kind,
float radius,
string name,
Mobility mobility,
bool isOrbiting,
bool isMasking,
bool isSolid,
float gravity,
Vector position,
Vector movement,
Vector orbitingCenter = null,
IEnumerable <OrbitingState> orbitingList = null)
{
Map = map;
Kind = kind;
RadiusInternal = radius;
Name = name;
this.mobility = mobility;
this.isOrbiting = isOrbiting;
this.isMasking = isMasking;
this.isSolid = isSolid;
this.gravity = gravity;
PositionInternal = position;
MovementInternal = movement;
if (isOrbiting)
{
OrbitingCenter = orbitingCenter;
this.orbitingList = new List <UnitOrbitingState>();
foreach (var orbitingState in orbitingList)
{
this.orbitingList.Add(new UnitOrbitingState(orbitingState));
}
}
AgeInternal = 0;
}
// 유닛 생성, 삭제 방식을 Object Pool로 변경
private void ObjectPoolSetting()
{
for (int i = 0; i < Units.Count; i++)
{
UnitKind unitKind = Units[i].UnitType;
GameObject unitObj = Units[i].Object;
units.Add((UnitKind)i, new ObjectPoolStack <Unit>(5, () =>
{
GameObject obj = Instantiate(unitObj, UnitZone);
obj.SetActive(false);
Unit unit = obj.GetComponent <Unit>();
unit.Status = unitStatuses[unitKind];
return(unit);
}));
}
}
private void recall(GameObject unit, UnitKind kind)
{
switch (kind)
{
case UnitKind.Policy:
unit.SetActive(false);
policiesPool.Push(unit);
break;
case UnitKind.Fireman:
unit.SetActive(false);
firemanPool.Push(unit);
break;
case UnitKind.Doctor:
unit.SetActive(false);
doctorsPool.Push(unit);
break;
}
}
public static ShortTimeSpan FromString(string str)
{
str = str.Trim();
UnitKind scale = UnitKind.Seconds;
if (str.EndsWith("ms"))
{
scale = UnitKind.Milliseconds;
}
else if (str.EndsWith("μs") || str.EndsWith("us")) // support mu symbol for forward compatibility use
{
scale = UnitKind.Microseconds;
}
else if (str.EndsWith("ns"))
{
scale = UnitKind.Nanoseconds;
}
else if (str.EndsWith("s"))
{
}
int index = 0;
for (; index < str.Length; index++)
{
if (char.IsNumber(str[index]) || str[index] == '.')
{
continue;
}
else
{
break;
}
}
str = str.Substring(0, index);
var val = double.Parse(str, NumberStyles.Any, CultureInfo.InvariantCulture);
return(new ShortTimeSpan {
Value = val, unit = scale
});
}
public Product(Guid id, string reference, string name, ConditioningKind conditioning, UnitKind unit,
decimal quantityPerUnit, Producer producer)
{
Id = id;
Producer = producer ?? throw SheaftException.Validation("Le producteur du produit est requis.");
ProducerId = producer.Id;
SetName(name);
SetReference(reference);
SetConditioning(conditioning, quantityPerUnit, unit);
Tags = new List <ProductTag>();
Ratings = new List <Rating>();
CatalogsPrices = new List <CatalogProduct>();
DomainEvents = new List <DomainEvent>();
VisibleTo = VisibleToKind.None;
RefreshRatings();
RefreshPrices();
}
/// <summary>
/// ctor
/// </summary>
/// <param name="value">栄養素の成分値</param>
/// <param name="unitKind">単位の種類 e.g) mg, g, kcal, etc...</param>
/// <param name="isEstimateValue">成分値は推定値か</param>
public Nutrient(double value, UnitKind unitKind, bool isEstimateValue)
{
this.Value = value;
this.UnitKind = unitKind;
this.IsEstimateValue = isEstimateValue;
}
/// <summary>
/// Initializes an instance of the <see cref="UnitValue"/> class.
/// </summary>
/// <param name="baseValue">The base value.</param>
/// <param name="unit">The unit kind.</param>
public UnitValue(float baseValue, UnitKind unit)
: this(baseValue, unit, PrefixKind.None)
{
}
public int GetExponent(UnitKind kind)
{
return(DecodeExponent(GetElement(kind)));
}
/// <summary>
/// 引数の単位に栄養価を変換する
/// </summary>
/// <param name="unit"></param>
/// <returns></returns>
public double ConvertValue(UnitKind unit)
{
if (unit == UnitKind.Undefine)
{
throw new ArgumentException("UnitKindが未定義です。");
}
switch (this.UnitKind)
{
case UnitKind.kcal:
if (unit == UnitKind.kj)
{
return(this.Value * 4.184);
}
else
{
throw new ArgumentException($"{this.UnitKind}を{unit}に変換できません。");
}
case UnitKind.kj:
if (unit == UnitKind.kcal)
{
return(this.Value / 4.184);
}
else
{
throw new ArgumentException($"{this.UnitKind}を{unit}に変換できません。");
}
case UnitKind.g:
if (unit == UnitKind.mg)
{
return(this.Value * 1000);
}
else if (unit == UnitKind.micro_g)
{
return(this.Value * 1000000);
}
else
{
throw new ArgumentException($"{this.UnitKind}を{unit}に変換できません。");
}
case UnitKind.mg:
if (unit == UnitKind.g)
{
return(this.Value * 0.001);
}
else if (unit == UnitKind.micro_g)
{
return(this.Value * 1000);
}
else
{
throw new ArgumentException($"{this.UnitKind}を{unit}に変換できません。");
}
case UnitKind.micro_g:
if (unit == UnitKind.g)
{
return(this.Value * 0.000001);
}
else if (unit == UnitKind.mg)
{
return(this.Value * 0.001);
}
else
{
throw new ArgumentException($"{this.UnitKind}を{unit}に変換できません。");
}
case UnitKind.percent:
throw new ArgumentException("%は変換先がありません。");
case UnitKind.Undefine:
default:
throw new ArgumentException("UnitKindが未定義です。");
}
}
public void SetExponent(UnitKind kind, int value)
{
SetElement(kind, EncodeExponent(value));
}
void Update()
{
Vector3 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
if (Input.GetMouseButtonDown(0) && !EventSystem.current.IsPointerOverGameObject())
{
RaycastHit hit;
if (Physics.Raycast(mousePos, Vector3.down, out hit))
{
if (hit.collider != null)
{
if (hit.collider.gameObject == commandPostButton && isPlacedCommandPost == false)
{
currentChoose = Instantiate(commandPostPrefab, mousePos, transform.rotation);
currentChooseKind = UnitKind.CommandPost;
}
else if (hit.collider.gameObject == heavyTankButton && points >= 1)
{
currentChoose = Instantiate(heavyTankPrefab, mousePos, transform.rotation);
currentChooseKind = UnitKind.HeavyTank;
}
else if (hit.collider.gameObject == missileTankButton && points >= 1)
{
currentChoose = Instantiate(missileTankPrefab, mousePos, transform.rotation);
currentChooseKind = UnitKind.MissileTank;
}
else if (hit.collider.gameObject == howitzerButton && points >= 2 && howitzerCount < 5)
{
currentChoose = Instantiate(howitzerPrefab, mousePos, transform.rotation);
currentChooseKind = UnitKind.Howitzer;
}
else if (hit.collider.gameObject == gevButton && points >= 1)
{
currentChoose = Instantiate(gevPrefab, mousePos, transform.rotation);
currentChooseKind = UnitKind.GEV;
}
}
}
}
if (Input.GetMouseButton(0))
{
if (currentChoose != null)
{
currentChoose.transform.position = new Vector3(mousePos.x, 5.0f, mousePos.z);
if (IsBlock(mousePos))
{
error.SetActive(true);
error.transform.position = new Vector3(mousePos.x, 30.0f, mousePos.z);
}
else
{
error.SetActive(false);
}
}
}
if (Input.GetMouseButtonUp(0))
{
if (currentChoose != null && IsBlock(mousePos))
{
error.SetActive(false);
Destroy(currentChoose);
currentChoose = null;
}
else if (currentChoose != null && !IsBlock(mousePos))
{
units.Add(currentChoose);
currentChoose = null;
if (currentChooseKind == UnitKind.CommandPost)
{
isPlacedCommandPost = true;
}
else if (currentChooseKind == UnitKind.HeavyTank)
{
points -= 1;
}
else if (currentChooseKind == UnitKind.MissileTank)
{
points -= 1;
}
else if (currentChooseKind == UnitKind.Howitzer)
{
points -= 2;
howitzerCount++;
}
else if (currentChooseKind == UnitKind.GEV)
{
points -= 1;
}
pointsText.text = "Points: " + points.ToString();
}
}
}
uint GetElement(UnitKind kind)
{
int index = (int)kind;
return((RawValue >> (index << 2)) & 0xf);
}
internal BaseUnit(UnitKind kind, UnitPrefix prefix, double?exponent = null)
{
this.Kind = kind;
this.Prefix = prefix;
this.Exponent = exponent;
}
void SetElement(UnitKind kind, uint value)
{
int index = (int)kind;
RawValue &= 0xfu << (index << 2); RawValue |= (value & 0xfu) << (index << 2);
}
/// <summary>
/// Initializes an instance of the <see cref="UnitValue"/> class.
/// </summary>
/// <param name="baseValue">The base value.</param>
/// <param name="unit">The unit kind.</param>
/// <param name="prefix">The prefix.</param>
public UnitValue(float baseValue, UnitKind unit, PrefixKind prefix)
{
BaseValue = baseValue;
Prefix = prefix;
Unit = unit;
}
