public ValidationContext(ICollection <CommandType> alreadyExecuted, TemperatureType temperatureType,
ICollection <CommandType> requestedCommands)
{
AlreadyExecuted = alreadyExecuted;
TemperatureType = temperatureType;
RequestedCommands = requestedCommands;
}
public double GetTemperature(TemperatureType type = TemperatureType.Celsius)
{
//System.Threading.Thread.Sleep(40);
uint16_t t = read16(MCP9808_REG_AMBIENT_TEMP);
double temp = t & 0x0FFF;
temp /= 16.0;
if ((t & 0x1000) == 0x1000)
{
temp -= 256;
}
switch (type)
{
case TemperatureType.Celsius: return(temp);
case TemperatureType.Fahrenheit: return(CelsiusToFahrenheit(temp));
case TemperatureType.Kelvin: return(temp * CELCIUS_TO_KELVIN);
default:
throw new ArgumentException();
}
}
public float GetSafeCookTemp(string meat, TemperatureType tempType)
{
meat = meat.ToLower();
if (tempType == TemperatureType.Fahrenheit)
{
switch (meat)
{
case "beef":
case "pork":
case "veal":
return(145f);
case "chicken":
case "turkey":
default:
return(165f);
}
}
else if (tempType == TemperatureType.Celsius)
{
switch (meat)
{
case "beef":
case "pork":
case "veal":
return(64f);
case "chicken":
case "turkey":
default:
return(74f);
}
}
throw new ArgumentException("Unknown temperature type: " + tempType.ToString());
}
public void Init(PlantScriptableObj plantScript, Vector2Int plantGridPos)
{
m_GrowthTime = plantScript.m_GrowthTime;
m_PlantTime = plantScript.m_PlantTime;
m_TemperatureToGrow = plantScript.m_TemperatureToGrow;
m_CurrentHealth = plantScript.m_PlantHealth;
m_PlantGridPos = plantGridPos;
m_PlantType = plantScript.m_PlantType;
//set sprite stuff
m_SpriteRenderer.sprite = plantScript.m_PlantSprite;
m_SpriteRenderer.color = Color.white;
m_SpriteRenderer.sortingOrder = (int)(transform.position.y * -100);
m_Dead = false;
if (m_Animator != null)
{
m_Animator.ResetTrigger("Shaking");
m_Animator.ResetTrigger("Dying");
}
Temperature temperature = GameStats.Instance.m_Temperature;
if (temperature != null)
{
CheckTemperatureUpdate(temperature.m_CurrTempType);
}
}
/// <summary>
/// Returns tempeature based on sensor
/// See http://www.ladyada.net/learn/sensors/tmp36.html
/// </summary>
/// <param name="ttype">Should temperature be in Cellsius degrees or Farrenheit</param>
/// <returns>string containing interpretation of value from CS</returns>
public TemperatureResult GetTemperature(TemperatureType ttype = TemperatureType.Cellsius)
{
//getting the voltage reading from the temperature sensor
int reading = GetRaw();
double voltage = GetVoltage(reading);
// now calculate the temperature
//converting from 10 mv per degree with 500 mV offset
//to degrees ((volatge - 500mV) times 100)
double temperatureC = (voltage - 0.5) * 100;
// now convert to Farrenheit
double temperatureF = (temperatureC * 9.0 / 5.0) + 32.0;
TemperatureResult result = new TemperatureResult();
result.Type = ttype;
result.Voltage = voltage;
result.VoltageString = voltage.ToString("F") + "v";
if (ttype == TemperatureType.Cellsius)
{
result.Temperature = temperatureC;
result.TemperatureString = temperatureC.ToString("F") + "C";
}
else
{
result.Temperature = temperatureF;
result.TemperatureString = temperatureC.ToString("F") + "F";
}
return(result);
}
public double GetTemperature(TemperatureType type)
{
if (temperatureProvider.GetType() == typeof(TempData))
{
var temp = (TempData)temperatureProvider;
switch (type)
{
case TemperatureType.C: return(temp.Celsii);
case TemperatureType.K: return(temp.Kelvin);
case TemperatureType.F: return(temp.Farengeit);
}
}
if (temperatureProvider.GetType() == typeof(TempCalculator))
{
var temp = (TempCalculator)temperatureProvider;
switch (type)
{
case TemperatureType.C: return(temp.C);
case TemperatureType.K: return(temp.K);
case TemperatureType.F: return(temp.F);
}
}
throw new NotImplementedException();
}
public void Validate(TemperatureType temperatureType, ICollection <CommandType> commands)
{
var ctx = new ValidationContext(new List <CommandType>(), temperatureType, commands);
var cancelValidation = false;
foreach (var command in commands)
{
if (cancelValidation)
{
break;
}
ctx.CurrentCommand = command;
var anyRulesFailed = false;
var ruleRunner = new RuleRunner <ValidationContext>(_rulePack);
ruleRunner.RuleRan += (object sender, RuleRanEventArgs <ValidationContext> e, ref bool cancel) =>
{
if (!e.Passed)
{
anyRulesFailed = true;
}
OnRuleRan(new RuleRanEventArgs(e.Rule.Method, e.Passed, command), ref cancel);
};
ruleRunner.Run(ctx);
OnCommandValidated(new DressCommandValidationEventArgs(command, anyRulesFailed), ref cancelValidation);
ctx.AlreadyExecuted.Add(command);
}
}
public WeatherForecast Convert(TemperatureType type, double value)
{
var weatherForecast = new WeatherForecast();
switch (type)
{
case TemperatureType.Celsius:
weatherForecast.Celsius = value;
weatherForecast.Kelvin = 273 + value;
weatherForecast.Fahrenheit = value * 18 / 10 + 32;
break;
case TemperatureType.Kelvin:
weatherForecast.Kelvin = value;
weatherForecast.Celsius = value - 273;
weatherForecast.Fahrenheit = (value - 273) * 18 / 10 + 32;
break;
case TemperatureType.Fahrenheit:
weatherForecast.Fahrenheit = value;
weatherForecast.Celsius = 5 * (value - 32) / 9;
weatherForecast.Kelvin = 5 * (value - 32) / 9 + 273;
break;
default:
break;
}
return(weatherForecast);
}
/// <summary>
/// Returns tempeature based on sensor
/// See http://www.ladyada.net/learn/sensors/tmp36.html
/// </summary>
/// <param name="ttype">Should temperature be in Cellsius degrees or Farrenheit</param>
/// <returns>string containing interpretation of value from CS</returns>
public TemperatureResult GetTemperature(TemperatureType ttype = TemperatureType.Cellsius)
{
//getting the voltage reading from the temperature sensor
int reading = GetRaw();
double voltage = GetVoltage(reading);
// now calculate the temperature
//converting from 10 mv per degree with 500 mV offset
//to degrees ((volatge - 500mV) times 100)
double temperatureC = (voltage - 0.5) * 100;
// now convert to Farrenheit
double temperatureF = (temperatureC * 9.0 / 5.0) + 32.0;
TemperatureResult result = new TemperatureResult();
result.Type = ttype;
result.Voltage = voltage;
result.VoltageString = voltage.ToString("F") + "v";
if (ttype == TemperatureType.Cellsius)
{
result.Temperature = temperatureC;
result.TemperatureString = temperatureC.ToString("F") + "C";
}
else
{
result.Temperature = temperatureF;
result.TemperatureString = temperatureC.ToString("F") + "F";
}
return result;
}
public void CheckTemperatureUpdate(TemperatureType currTemperature)
{
//check if plant can still survive when the temperature increased
if (currTemperature < m_TemperatureToGrow)
{
Dead();
}
}
public async Task <sbyte> GetTemperature(TemperatureType type = TemperatureType.Celsius)
{
var temperature = await this.sensorReader.ReadSensor(Packets.Temperature)
.ConfigureAwait(false);
var tc = (sbyte)temperature.RawData[0];
return(type == TemperatureType.Celsius ? tc : (sbyte)(tc * 1.8 + 32));
}
public ActionResult GetBoilingTemperature(Guid compoundId, TemperatureType type)
{
Log.Information("GET Compound/GetBoilingTemperature triggered");
var compoundElements = _repo.GetCompoundElementsByCompoundId(compoundId);
double boilingTemperature = CompoundCalculator.GetBoilingTemperature(compoundElements, type);
return(Json(boilingTemperature, JsonRequestBehavior.AllowGet));
}
public float GetSafeCookTemp(string meat, TemperatureType temperatureType)
{
if (temperatureType == TemperatureType.Farenheit)
{
return(meat switch
{
"beef" or "pork" => 145f,
"chicken" or "turkey" => 165f,
_ => 165f,
});
private static TempResponse InvalidParameter(TemperatureType from, TemperatureType to, double rng, string msg = "Invalid Parameter")
{
return(new TempResponse
{
From = (short)from,
Value = rng,
To = (short)to,
Message = msg
});
}
public static float ConvertTemperature(float value, TemperatureType from, TemperatureType to)
{
switch (from)
{
case TemperatureType.Kelvin:
switch (to)
{
case TemperatureType.Kelvin:
break;
case TemperatureType.Celsius:
value = value - 273.15f;
break;
case TemperatureType.Fahrenheit:
value = (value - 273.15f) * 9f / 5f + 32f;
break;
}
break;
case TemperatureType.Celsius:
switch (to)
{
case TemperatureType.Kelvin:
value = value + 273.15f;
break;
case TemperatureType.Celsius:
break;
case TemperatureType.Fahrenheit:
value = value * 9f / 5f + 32;
break;
}
break;
case TemperatureType.Fahrenheit:
switch (to)
{
case TemperatureType.Kelvin:
value = (value - 32f) * 5f / 9f + 273.15f;
break;
case TemperatureType.Celsius:
value = (value - 32f) * 5f / 9f;
break;
case TemperatureType.Fahrenheit:
break;
}
break;
}
return(value);
}
public virtual double GetTemperature(TemperatureType type = TemperatureType.Celsius)
{
switch (type)
{
case TemperatureType.Celsius: return this._celsiusValue;
case TemperatureType.Fahrenheit: return CelsiusToFahrenheit(GetTemperature(TemperatureType.Celsius));
case TemperatureType.Kelvin: return CelsiusToKelvin(GetTemperature(TemperatureType.Celsius));
default:
throw new ArgumentException();
}
}
private static void PrintConversion(double value, TemperatureType type)
{
double tempCelsius, tempFahrenheit, tempKelvin, tempReamur;
switch (type)
{
case TemperatureType.CELSIUS:
{
tempCelsius = value;
tempFahrenheit = tempCelsius * 9 / 5 + 32;
tempKelvin = tempCelsius - 273.15;
tempReamur = tempCelsius / 1.25;
break;
}
case TemperatureType.FAHRENHEIT:
{
tempFahrenheit = value;
tempCelsius = (tempFahrenheit - 32) * 5 / 9;
tempKelvin = tempCelsius - 273.15;
tempReamur = tempCelsius / 1.25;
break;
}
case TemperatureType.KELVIN:
{
tempKelvin = value;
tempCelsius = tempKelvin + 273.15;
tempFahrenheit = tempCelsius * 9 / 5 + 32;
tempReamur = tempCelsius / 1.25;
break;
}
case TemperatureType.REAMUR:
{
tempReamur = value;
tempCelsius = tempReamur * 1.25;
tempFahrenheit = tempCelsius * 9 / 5 + 32;
tempKelvin = tempCelsius - 273.15;
break;
}
default:
{
Console.WriteLine("Fehler 404 aufgetreten, Temperatureinheit konnte nicht gefunden werden.");
return;
}
}
Console.WriteLine($" Celsius: {tempCelsius}\n");
Console.WriteLine($"Fahrenheit: {tempFahrenheit}\n");
Console.WriteLine($" Reamur: {tempReamur}\n");
Console.WriteLine($" Kelvin: {tempKelvin}\n");
}
static void Main(string[] args)
{
TemperatureType type = TemperatureType.HOT;
string inputCommands = "8, 6, 6";
// "Removing PJs", "shorts", "fail"
TemperatureStrategy temperatureStrategy = StrategyResolver.GetTemperatureStrategy(type);
temperatureStrategy.ProcessCommands(inputCommands);
Console.WriteLine(string.Join(",", temperatureStrategy._output));
Console.WriteLine(temperatureStrategy._message);
Console.ReadKey();
}
public void ShouldHaveFailWhenSameClothingAddedTwice()
{
TemperatureType type = TemperatureType.HOT;
string inputCommands = "8, 6, 6";
List <string> expectedOutput = new List <string> {
"Removing PJs", "shorts", "fail"
};
TemperatureStrategy temperatureStrategy = StrategyResolver.GetTemperatureStrategy(type);
temperatureStrategy.ProcessCommands(inputCommands);
CollectionAssert.AreEqual(expectedOutput, temperatureStrategy._output as List <string>);
TestContext.WriteLine(temperatureStrategy._message);
}
public void ShouldHaveFailWhenFirstCommandIsNotToRemovePajamas()
{
TemperatureType type = TemperatureType.COLD;
string inputCommands = "6";
List <string> expectedOutput = new List <string> {
"fail"
};
TemperatureStrategy temperatureStrategy = StrategyResolver.GetTemperatureStrategy(type);
temperatureStrategy.ProcessCommands(inputCommands);
CollectionAssert.AreEqual(expectedOutput, temperatureStrategy._output as List <string>);
TestContext.WriteLine(temperatureStrategy._message);
}
public void ShouldHaveFailWhenAnyCommandIsNotANumber()
{
TemperatureType type = TemperatureType.COLD;
string inputCommands = "8, 6, zz, 4, 2, 5, 1, 7";
List <string> expectedOutput = new List <string> {
"Removing PJs", "pants", "fail"
};
TemperatureStrategy temperatureStrategy = StrategyResolver.GetTemperatureStrategy(type);
temperatureStrategy.ProcessCommands(inputCommands);
CollectionAssert.AreEqual(expectedOutput, temperatureStrategy._output as List <string>);
TestContext.WriteLine(temperatureStrategy._message);
}
public void ShouldHaveFailWhenFirstElementIsNotANumber()
{
TemperatureType type = TemperatureType.HOT;
string inputCommands = "zz, 6, 4, 2, 1, 7";
List <string> expectedOutput = new List <string> {
"fail"
};
TemperatureStrategy temperatureStrategy = StrategyResolver.GetTemperatureStrategy(type);
temperatureStrategy.ProcessCommands(inputCommands);
CollectionAssert.AreEqual(expectedOutput, temperatureStrategy._output as List <string>);
TestContext.WriteLine(temperatureStrategy._message);
}
public float GetSafeCookTemp(string meat, TemperatureType temperatureType)
{
switch (temperatureType)
{
case TemperatureType.Fahrenheit:
return(GetFahrenheitTemps(meat));
case TemperatureType.Celsius:
return(GetCelsiusTemps(meat));
default:
throw new Exception("Unknown TemperatureType");
}
}
public virtual double GetTemperature(TemperatureType type = TemperatureType.Celsius)
{
switch (type)
{
case TemperatureType.Celsius: return(this._celsiusValue);
case TemperatureType.Fahrenheit: return(CelsiusToFahrenheit(GetTemperature(TemperatureType.Celsius)));
case TemperatureType.Kelvin: return(CelsiusToKelvin(GetTemperature(TemperatureType.Celsius)));
default:
throw new ArgumentException();
}
}
/// <summary>
/// At present, HOT & COLD are supported. In future, to support new strategy, modify this method.
/// </summary>
/// <param name="temperatureType">HOT Or COLD</param>
/// <returns></returns>
public static TemperatureStrategy GetTemperatureStrategy(TemperatureType temperatureType)
{
switch (temperatureType)
{
case TemperatureType.HOT:
return(new HotTemperatureStrategy());
case TemperatureType.COLD:
return(new ColdTemperatureStrategy());
default:
throw new TypeAccessException();
}
}
//Calculate boiling points, reference: https://www.thoughtco.com/temperature-conversion-formulas-609324
public static double Convert(double temperatureK, TemperatureType temperatureType)
{
switch (temperatureType)
{
case TemperatureType.Celsius:
return(Math.Round(temperatureK - 273.15, 3));
case TemperatureType.Fahrenheit:
return(Math.Round((temperatureK - 273.15) * (9d / 5) + 32, 3));
default:
return(0d);
}
}
public void ShowTemperatureMessage(TemperatureType temperatureType)
{
string temperatureTypeString = "";
switch (temperatureType)
{
case TemperatureType.Minimum: temperatureTypeString = "minimum";
break;
case TemperatureType.Maximum: temperatureTypeString = "maximum";
break;
}
Console.WriteLine($"Enter {temperatureTypeString} temperature. (Integer number)");
}
public override double GetTemperature(TemperatureType type = TemperatureType.Celsius)
{
this._celsiusValue = __GetTemperature();
switch (type)
{
case TemperatureType.Celsius: return(this._celsiusValue);
case TemperatureType.Fahrenheit: return(base.CelsiusToFahrenheit(this._celsiusValue));
case TemperatureType.Kelvin: return(base.CelsiusToKelvin(this._celsiusValue));
default:
throw new ArgumentException();
}
}
public DressResult Dress(TemperatureType temperatureType, ICollection <CommandType> commands)
{
var commandResults = new List <DressCommandResult>();
var ruleResults = new List <DressCommandRuleResult>();
Action setupValidator = () =>
{
_validator.RuleRan += (object sender, RuleRanEventArgs e, ref bool cancel) =>
{
if (!e.Passed)
{
cancel = true;
}
ruleResults.Add(new DressCommandRuleResult {
Command = e.Command, Passed = e.Passed, RuleName = e.Rule.Name
});
};
_validator.CommandValidated += (object sender, DressCommandValidationEventArgs e, ref bool cancel) =>
{
if (e.AnyRulesFailed)
{
cancel = true;
}
commandResults.Add(new DressCommandResult {
Command = e.Command, Passed = !e.AnyRulesFailed
});
};
};
setupValidator();
_validator.Validate(temperatureType, commands);
Func <IEnumerable <string> > determineResponseForEachCommand = () =>
{
return(commandResults.Select(r => r.Passed ? _responseFinder(temperatureType, r.Command) : Resources.FailLiteral));
};
var responses = determineResponseForEachCommand();
return(new DressResult {
CommandResults = commandResults,
RuleResults = ruleResults,
Message = string.Join(", ", responses)
});
}
public void SetTemperature(double temp, TemperatureType type)
{
switch (type)
{
case TemperatureType.Kelvin:
if (Kelvin < 0)
{
throw new TemperatureException("A temperature this low is not physically possible");
}
else
{
Kelvin = temp;
Celsius = KelvinToCelsius(temp);
Fahrenheit = KelvinToFahrenheit(temp);
}
break;
case TemperatureType.Celsius:
if (CelsiusToKelvin(temp) < 0)
{
throw new TemperatureException("A temperature this low is not physically possible");
}
else
{
Kelvin = CelsiusToKelvin(temp);
Celsius = temp;
Fahrenheit = CelsiusToFahrenheit(temp);
}
break;
case TemperatureType.Fahrenheit:
if (Kelvin < 0)
{
throw new TemperatureException("A temperature this low is not physically possible");
}
else
{
Kelvin = FahrenheitToKelvin(temp);
Celsius = FahrenheitToCelsius(temp);
Fahrenheit = temp;
}
break;
}
}
public void UpdateTemperature()
{
m_CurrTemperatureAmt = m_TreeAmt * m_TemperaturePerTree + m_PlantAmt * m_TemperaturePerPlant;
m_CurrTemperatureAmt += m_TemperatureOffset;
//based on plant and flower count
if (m_CurrTemperatureAmt > m_TreeToTemperature[(int)m_CurrTempType])
{
m_CurrTempType += 1; //go to next temperature type
if (m_CurrTempType > TemperatureType.NICE)
{
m_CurrTempType = TemperatureType.NICE;
}
else
{
MapManager.Instance.AllPlantsTreesUpdateTemperature();
}
UIManager.Instance.SetTemperatureUI(m_CurrTempType);
}
else
{
if (m_CurrTempType == 0)
{
return;
}
if (m_CurrTemperatureAmt < m_TreeToTemperature[(int)m_CurrTempType - 1])
{
m_CurrTempType -= 1;
if (m_CurrTempType < 0)
{
m_CurrTempType = TemperatureType.EXTREMELY_HOT;
}
else
{
MapManager.Instance.AllPlantsTreesUpdateTemperature();
}
UIManager.Instance.SetTemperatureUI(m_CurrTempType);
}
}
}
public ActionResult GetAll(TemperatureType type)
{
Log.Information("GET Element/GetAll triggered");
var elements = _repo.GetAllElements();
//Map to DTO object
var elementDtos = Mapper.Map <List <ElementDto> >(elements);
//Recalculate temperature
if (type != TemperatureType.Kelvin)
{
foreach (var element in elementDtos)
{
element.BoilingTemperature = TemperatureConverter.Convert(element.BoilingTemperature, type);
}
}
return(Json(elementDtos, JsonRequestBehavior.AllowGet));
}
public static string GetTemperatureNoticeStr(ScannerMonitorData monitorData,
TemperatureType tempDisplayType)
{
string valueStr = CommonStaticValue.DisplayTypeStr[(int)MonitorDisplayType.Temperature] + ":";
if (monitorData == null)
{
valueStr += CommonStaticValue.StatusNoticeStr[(int)CommonStaticValue.NoticeType.Unkown];
return valueStr;
}
if (monitorData.TemperatureOfScanCard.IsValid)
{
//��ؿ��¶�
int nValue = (int)GetDisplayTempValueByCelsius(tempDisplayType,
monitorData.TemperatureOfScanCard.Value);
valueStr += nValue.ToString();
}
else
{
valueStr += CommonStaticValue.StatusNoticeStr[(int)CommonStaticValue.NoticeType.Unkown];
}
return valueStr;
}
/// <summary>
/// ��ȡ��ͬ�¶ȵ���ɫ
/// </summary>
/// <param name="scanBordAddr"></param>
/// <param name="curScanBordIndex"></param>
/// <param name="tempObject"></param>
/// <param name="clr"></param>
public static bool DetectTempIsValidAndGetInfo(ColorGradePartition clrGradePartition,
TemperatureType tempDisplayType,
ScannerMonitorData monitorData,
ref int value, ref Color clr)
{
if (monitorData != null)
{
//ErrorCode -- Error
//if (monitorData.TemperatureOfMonitorCard.IsValid)
//{
// //��ؿ��¶���Ч
// value = monitorData.TemperatureOfMonitorCard.Value;
//}
//else if (monitorData.TemperatureOfScanCard.IsValid)
//{
// //��ؿ��¶���Ч
// value = monitorData.TemperatureOfScanCard.Value;
//}
if (monitorData.TemperatureOfScanCard.IsValid)
{
//���տ��¶�
value = (int)GetDisplayTempValueByCelsius(tempDisplayType,
monitorData.TemperatureOfScanCard.Value);
}
else
{
clr = Color.Gray;
return false;
}
clrGradePartition.GetGradeColor(value, ref clr);
return true;
}
else
{
clr = Color.Gray;
return false;
}
}
public static float GetDisplayTempValueByCelsius(TemperatureType tempDisplayType, float fvalue)
{
if (tempDisplayType == TemperatureType.Celsius)
{
return fvalue;
}
else
{
return 32 + fvalue * 1.8f;
}
}
public double GetTemperature(TemperatureType type = TemperatureType.Celsius)
{
//System.Threading.Thread.Sleep(40);
uint16_t t = read16(MCP9808_REG_AMBIENT_TEMP);
double temp = t & 0x0FFF;
temp /= 16.0;
if ((t & 0x1000) == 0x1000) temp -= 256;
switch (type)
{
case TemperatureType.Celsius: return temp;
case TemperatureType.Fahrenheit: return CelsiusToFahrenheit(temp);
case TemperatureType.Kelvin: return temp*CELCIUS_TO_KELVIN;
default:
throw new ArgumentException();
}
}
public override void OnInspectorGUI ()
{
Climate_Zone_C self = (Climate_Zone_C)target;
//Time Number Variables
EditorGUILayout.LabelField("UniStorm Climate Generator", EditorStyles.boldLabel);
EditorGUILayout.LabelField("By: Black Horizon Studios", EditorStyles.label);
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUILayout.LabelField("Climate Options", EditorStyles.boldLabel);
EditorGUILayout.Space();
self.ClimateName = EditorGUILayout.TextField ("Climate Name", self.ClimateName);
EditorGUILayout.HelpBox("The name of your climate.", MessageType.None, true);
EditorGUILayout.Space();
editorDetectionType = (DetectionType)self.DetectionType;
editorDetectionType = (DetectionType)EditorGUILayout.EnumPopup("Detection Type", editorDetectionType);
self.DetectionType = (int)editorDetectionType;
EditorGUILayout.HelpBox("The Detection Type determins how your weather zone is triggered. This can be based on the Height (where your player must reach a certain height in order for the Climate Zone to change; this can be perfect for Mountains) or based on an OnTrigger collision (where you player must hit the trigger in order for the Climate Zone to change; perfect for Desert areas, Rainforests, Swamps, etc).", MessageType.None, true);
EditorGUILayout.Space();
if (self.DetectionType == 1)
{
bool PlayerObject = !EditorUtility.IsPersistent (self);
self.PlayerObject = (GameObject)EditorGUILayout.ObjectField ("Player Object", self.PlayerObject, typeof(GameObject), PlayerObject);
EditorGUILayout.HelpBox("Assign your player object here. The Climate System will use your player's height (Y position) to detect when to change Climate Zones.", MessageType.None, true);
EditorGUILayout.Space();
self.climateHeight = EditorGUILayout.IntField ("Climate Height", self.climateHeight);
EditorGUILayout.HelpBox("The height needed to change the Climate Zone.", MessageType.None, true);
EditorGUILayout.Space();
editorIfGreaterOrLessThan = (IfGreaterOrLessThan)self.ifGreaterOrLessThan;
editorIfGreaterOrLessThan = (IfGreaterOrLessThan)EditorGUILayout.EnumPopup("If Greater Or Less Than", editorIfGreaterOrLessThan);
self.ifGreaterOrLessThan = (int)editorIfGreaterOrLessThan;
EditorGUILayout.HelpBox("Based on the height above, does your player need to be above or below " + self.climateHeight.ToString() + " to make the climate change? Example: Moutains are above 300 units and Grasslands are below 300 units." , MessageType.None, true);
EditorGUILayout.Space();
self.updateInterval = EditorGUILayout.FloatField ("Update Interval", self.updateInterval);
EditorGUILayout.HelpBox("How often (in seconds) the Climate Zone is updated to check the player's height" , MessageType.None, true);
}
if (self.DetectionType == 0)
{
self.playerTag = EditorGUILayout.TextField ("Tag Name", self.playerTag);
EditorGUILayout.HelpBox("The Tag name of your player.", MessageType.None, true);
EditorGUILayout.Space();
}
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUILayout.LabelField("Current Climate", EditorStyles.boldLabel);
EditorGUILayout.HelpBox("This is the current climate that is generated.", MessageType.None, true);
self.startingSpringTemp = EditorGUILayout.IntField ("Starting Spring Temp", self.startingSpringTemp);
self.minSpringTemp = EditorGUILayout.IntField ("Min Spring", self.minSpringTemp);
self.maxSpringTemp = EditorGUILayout.IntField ("Max Spring", self.maxSpringTemp);
EditorGUILayout.Space();
self.startingSummerTemp = EditorGUILayout.IntField ("Starting Summer Temp", self.startingSummerTemp);
self.minSummerTemp = EditorGUILayout.IntField ("Min Summer", self.minSummerTemp);
self.maxSummerTemp = EditorGUILayout.IntField ("Max Summer", self.maxSummerTemp);
EditorGUILayout.Space();
self.startingFallTemp = EditorGUILayout.IntField ("Starting Fall Temp", self.startingFallTemp);
self.minFallTemp = EditorGUILayout.IntField ("Min Fall", self.minFallTemp);
self.maxFallTemp = EditorGUILayout.IntField ("Max Fall", self.maxFallTemp);
EditorGUILayout.Space();
self.startingWinterTemp = EditorGUILayout.IntField ("Starting Winter Temp", self.startingWinterTemp);
self.minWinterTemp = EditorGUILayout.IntField ("Min Winter", self.minWinterTemp);
self.maxWinterTemp = EditorGUILayout.IntField ("Max Winter", self.maxWinterTemp);
EditorGUILayout.Space();
editorWeatherChance1 = (WeatherChanceDropDown1)self.weatherChanceSpring;
editorWeatherChance1 = (WeatherChanceDropDown1)EditorGUILayout.EnumPopup("Spring %", editorWeatherChance1);
self.weatherChanceSpring = (int)editorWeatherChance1;
editorWeatherChance2 = (WeatherChanceDropDown2)self.weatherChanceSummer;
editorWeatherChance2 = (WeatherChanceDropDown2)EditorGUILayout.EnumPopup("Summer %", editorWeatherChance2);
self.weatherChanceSummer = (int)editorWeatherChance2;
editorWeatherChance3 = (WeatherChanceDropDown3)self.weatherChanceFall;
editorWeatherChance3 = (WeatherChanceDropDown3)EditorGUILayout.EnumPopup("Fall %", editorWeatherChance3);
self.weatherChanceFall = (int)editorWeatherChance3;
editorWeatherChance4 = (WeatherChanceDropDown4)self.weatherChanceWinter;
editorWeatherChance4 = (WeatherChanceDropDown4)EditorGUILayout.EnumPopup("Winter %", editorWeatherChance4);
self.weatherChanceWinter = (int)editorWeatherChance4;
//EditorGUILayout.LabelField("Zone Weather Options", EditorStyles.boldLabel);
//editorWeatherType = (WeatherTypeDropDown)self.zoneWeather;
//editorWeatherType = (WeatherTypeDropDown)EditorGUILayout.EnumPopup("Zone Weather Type", editorWeatherType);
//self.zoneWeather = (int)editorWeatherType;
EditorGUILayout.Space();
EditorGUILayout.Space();
if(GUILayout.Button("Generate Climate"))
{
confirmationToGenerate = !confirmationToGenerate;
}
EditorGUILayout.HelpBox("Generate climate cannot be undone. Once this button has been pressed, your old settings will be gone.", MessageType.Warning, true);
EditorGUILayout.HelpBox("Generate Climate will randomize several UniStorm settings to generate a climate for you. This includeds Weather Odds, Min and Max Temperautes (as well as calculating your seasonal averages), Starting Time, Date, Starting Weather, Moon Phases, and more. This can be useful for testing randomized settings or even generating a climate for your games. The Presets all use real world data (excluding the Random Preset) to give you a well rounded generated climate of that type.", MessageType.None, true);
if (confirmationToGenerate)
{
EditorGUILayout.Space();
editorTemperatureType = (TemperatureType)self.TemperatureType;
editorTemperatureType = (TemperatureType)EditorGUILayout.EnumPopup("Temperautre Type", editorTemperatureType);
self.TemperatureType = (int)editorTemperatureType;
EditorGUILayout.HelpBox("The Temperautre Type determins whether Fahrenheit or Celsius temperatures will be generated. Both types will still use real-world data.", MessageType.None, true);
EditorGUILayout.Space();
EditorGUILayout.HelpBox("Generate climate cannot be undone. Once this button has been pressed, your old settings will be gone.", MessageType.Warning, true);
EditorGUILayout.HelpBox("Generating a new climate will change your current settings. This process cannot be undone. However, you can always reset to the default settings we used with our demos.", MessageType.Warning, true);
EditorGUILayout.Space();
EditorGUILayout.Space();
if(GUILayout.Button("Random"))
{
if (self.TemperatureType == 0)
{
self.minSpringTemp = Random.Range(35, 45);
self.maxSpringTemp = Random.Range(46, 60);
self.startingSpringTemp = (self.minSpringTemp + self.maxSpringTemp) / 2;
self.minSummerTemp = Random.Range(70, 80);
self.maxSummerTemp = Random.Range(81, 115);
self.startingSummerTemp = (self.minSummerTemp + self.maxSummerTemp) / 2;
self.minFallTemp = Random.Range(35, 45);
self.maxFallTemp = Random.Range(46, 60);
self.startingFallTemp = (self.minFallTemp + self.maxFallTemp) / 2;
self.minWinterTemp = Random.Range(-25, 0);
self.maxWinterTemp = Random.Range(1, 40);
self.startingWinterTemp = (self.minWinterTemp + self.maxWinterTemp) / 2;
}
if (self.TemperatureType == 1)
{
self.minSpringTemp = ((Random.Range(35, 45)) - 32) * 5/9;
self.maxSpringTemp = ((Random.Range(46, 60)) - 32) * 5/9;
self.startingSpringTemp = (self.minSpringTemp + self.maxSpringTemp) / 2;
self.minSummerTemp = ((Random.Range(70, 80)) - 32) * 5/9;
self.maxSummerTemp = ((Random.Range(81, 115)) - 32) * 5/9;
self.startingSummerTemp = (self.minSummerTemp + self.maxSummerTemp) / 2;
self.minFallTemp = ((Random.Range(35, 45)) - 32) * 5/9;
self.maxFallTemp = ((Random.Range(46, 60)) - 32) * 5/9;
self.startingFallTemp = (self.minFallTemp + self.maxFallTemp) / 2;
self.minWinterTemp = ((Random.Range(-25, 0)) - 32) * 5/9;
self.maxWinterTemp = ((Random.Range(1, 40)) - 32) * 5/9;
self.startingWinterTemp = (self.minWinterTemp + self.maxWinterTemp) / 2;
}
}
EditorGUILayout.HelpBox("A Random Climate will generate a random climate with no real world data. Everything is completely randomized, while still being realistic. This can give you very unique results which you can then alter how you'd like.", MessageType.None, true);
EditorGUILayout.Space();
EditorGUILayout.Space();
if(GUILayout.Button("Rainforest"))
{
self.weatherChanceSpring = 80;
self.weatherChanceSummer = 80;
self.weatherChanceFall = 80;
self.weatherChanceWinter = 80;
if (self.TemperatureType == 0)
{
self.minSpringTemp = Random.Range(75, 80);
self.maxSpringTemp = Random.Range(80, 85);
self.startingSpringTemp = (self.minSpringTemp + self.maxSpringTemp) / 2;
self.minSummerTemp = Random.Range(80, 85);
self.maxSummerTemp = Random.Range(85, 93);
self.startingSummerTemp = (self.minSummerTemp + self.maxSummerTemp) / 2;
self.minFallTemp = Random.Range(75, 80);
self.maxFallTemp = Random.Range(80, 85);
self.startingFallTemp = (self.minFallTemp + self.maxFallTemp) / 2;
self.minWinterTemp = Random.Range(68, 70);
self.maxWinterTemp = Random.Range(70, 75);
self.startingWinterTemp = (self.minWinterTemp + self.maxWinterTemp) / 2;
}
if (self.TemperatureType == 1)
{
self.minSpringTemp = ((Random.Range(75, 80)) - 32) * 5/9;
self.maxSpringTemp = ((Random.Range(80, 85)) - 32) * 5/9;
self.startingSpringTemp = (self.minSpringTemp + self.maxSpringTemp) / 2;
self.minSummerTemp = ((Random.Range(80, 85)) - 32) * 5/9;
self.maxSummerTemp = ((Random.Range(85, 93)) - 32) * 5/9;
self.startingSummerTemp = (self.minSummerTemp + self.maxSummerTemp) / 2;
self.minFallTemp = ((Random.Range(75, 80)) - 32) * 5/9;
self.maxFallTemp = ((Random.Range(80, 85)) - 32) * 5/9;
self.startingFallTemp = (self.minFallTemp + self.maxFallTemp) / 2;
self.minWinterTemp = ((Random.Range(68, 70)) - 32) * 5/9;
self.maxWinterTemp = ((Random.Range(70, 75)) - 32) * 5/9;
self.startingWinterTemp = (self.minWinterTemp + self.maxWinterTemp) / 2;
}
}
EditorGUILayout.HelpBox("The Rainforest Preset will generate a random Rainforest like Climate according to real world data.\n\nThe Rainforest climate consists of high odds of precipitation evenly distributed throughout the year. The yearly average temperature is relatively warm. It ralely exceeds 90° during the summer months and rarely falls below 68° during the winter.\n\nAfter your climate has been generated, you can tweak the settings to your liking.", MessageType.None, true);
EditorGUILayout.Space();
EditorGUILayout.Space();
if(GUILayout.Button("Desert"))
{
self.weatherChanceSpring = 20;
self.weatherChanceSummer = 20;
self.weatherChanceFall = 20;
self.weatherChanceWinter = 20;
if (self.TemperatureType == 0)
{
self.minSpringTemp = Random.Range(70, 85);
self.maxSpringTemp = Random.Range(85, 90);
self.startingSpringTemp = (self.minSpringTemp + self.maxSpringTemp) / 2;
self.minSummerTemp = Random.Range(90, 95);
self.maxSummerTemp = Random.Range(100, 120);
self.startingSummerTemp = (self.minSummerTemp + self.maxSummerTemp) / 2;
self.minFallTemp = Random.Range(70, 85);
self.maxFallTemp = Random.Range(85, 90);
self.startingFallTemp = (self.minFallTemp + self.maxFallTemp) / 2;
self.minWinterTemp = Random.Range(0, 50);
self.maxWinterTemp = Random.Range(50, 60);
self.startingWinterTemp = (self.minWinterTemp + self.maxWinterTemp) / 2;
}
if (self.TemperatureType == 1)
{
self.minSpringTemp = ((Random.Range(70, 85)) - 32) * 5/9;
self.maxSpringTemp = ((Random.Range(85, 90)) - 32) * 5/9;
self.startingSpringTemp = (self.minSpringTemp + self.maxSpringTemp) / 2;
self.minSummerTemp = ((Random.Range(90, 95)) - 32) * 5/9;
self.maxSummerTemp = ((Random.Range(100, 120)) - 32) * 5/9;
self.startingSummerTemp = (self.minSummerTemp + self.maxSummerTemp) / 2;
self.minFallTemp = ((Random.Range(70, 85)) - 32) * 5/9;
self.maxFallTemp = ((Random.Range(85, 90)) - 32) * 5/9;
self.startingFallTemp = (self.minFallTemp + self.maxFallTemp) / 2;
self.minWinterTemp = ((Random.Range(0, 50)) - 32) * 5/9;
self.maxWinterTemp = ((Random.Range(50, 60)) - 32) * 5/9;
self.startingWinterTemp = (self.minWinterTemp + self.maxWinterTemp) / 2;
}
}
EditorGUILayout.HelpBox("The Desert Preset will generate a random Desert like Climate according to real world data.\n\nThe Desert climate consists of very low odds of precipitation throughout the year. The average temperature is very hot duirng the Summer, but can be very cold during the Winter. Temperatures can often exceed 100° during the summer months and fall as cold as 0° during the winter.\n\nAfter your climate has been generated, you can tweak the settings to your liking.", MessageType.None, true);
EditorGUILayout.Space();
if(GUILayout.Button("Mountainous"))
{
self.weatherChanceSpring = 60;
self.weatherChanceSummer = 60;
self.weatherChanceFall = 60;
self.weatherChanceWinter = 60;
if (self.TemperatureType == 0)
{
self.minSpringTemp = Random.Range(45, 55);
self.maxSpringTemp = Random.Range(55, 70);
self.startingSpringTemp = (self.minSpringTemp + self.maxSpringTemp) / 2;
self.minSummerTemp = Random.Range(70, 90);
self.maxSummerTemp = Random.Range(90, 96);
self.startingSummerTemp = (self.minSummerTemp + self.maxSummerTemp) / 2;
self.minFallTemp = Random.Range(40, 50);
self.maxFallTemp = Random.Range(50, 65);
self.startingFallTemp = (self.minFallTemp + self.maxFallTemp) / 2;
self.minWinterTemp = Random.Range(-30, 10);
self.maxWinterTemp = Random.Range(10, 30);
self.startingWinterTemp = (self.minWinterTemp + self.maxWinterTemp) / 2;
}
if (self.TemperatureType == 1)
{
self.minSpringTemp = ((Random.Range(45, 55)) - 32) * 5/9;
self.maxSpringTemp = ((Random.Range(55, 70)) - 32) * 5/9;
self.startingSpringTemp = (self.minSpringTemp + self.maxSpringTemp) / 2;
self.minSummerTemp = ((Random.Range(70, 90)) - 32) * 5/9;
self.maxSummerTemp = ((Random.Range(90, 96)) - 32) * 5/9;
self.startingSummerTemp = (self.minSummerTemp + self.maxSummerTemp) / 2;
self.minFallTemp = ((Random.Range(40, 50)) - 32) * 5/9;
self.maxFallTemp = ((Random.Range(50, 65)) - 32) * 5/9;
self.startingFallTemp = (self.minFallTemp + self.maxFallTemp) / 2;
self.minWinterTemp = ((Random.Range(-30, 10)) - 32) * 5/9;
self.maxWinterTemp = ((Random.Range(10, 30)) - 32) * 5/9;
self.startingWinterTemp = (self.minWinterTemp + self.maxWinterTemp) / 2;
}
}
EditorGUILayout.HelpBox("The Mountainous Preset will generate a random Mountainous like Climate according to real world data. \n\nThe Mountainous climate consists of medium to high odds of precipitation throughout the year. The average temperature is relatively mild during the Summer and very cold during the Winter. Temperatures can rarely exceed 86° during the summer months and fall as cold as -22° during the winter.\n\nAfter your climate has been generated, you can tweak the settings to your liking.", MessageType.None, true);
EditorGUILayout.Space();
if(GUILayout.Button("Grassland"))
{
self.weatherChanceSpring = 60;
self.weatherChanceSummer = 60;
self.weatherChanceFall = 20;
self.weatherChanceWinter = 20;
if (self.TemperatureType == 0)
{
self.minSpringTemp = Random.Range(50, 85);
self.maxSpringTemp = Random.Range(85, 90);
self.startingSpringTemp = (self.minSpringTemp + self.maxSpringTemp) / 2;
self.minSummerTemp = Random.Range(90, 95);
self.maxSummerTemp = Random.Range(95, 115);
self.startingSummerTemp = (self.minSummerTemp + self.maxSummerTemp) / 2;
self.minFallTemp = Random.Range(50, 85);
self.maxFallTemp = Random.Range(85, 90);
self.startingFallTemp = (self.minFallTemp + self.maxFallTemp) / 2;
self.minWinterTemp = Random.Range(30, 40);
self.maxWinterTemp = Random.Range(40, 50);
self.startingWinterTemp = (self.minWinterTemp + self.maxWinterTemp) / 2;
}
if (self.TemperatureType == 1)
{
self.minSpringTemp = ((Random.Range(50, 85)) - 32) * 5/9;
self.maxSpringTemp = ((Random.Range(85, 90)) - 32) * 5/9;
self.startingSpringTemp = (self.minSpringTemp + self.maxSpringTemp) / 2;
self.minSummerTemp = ((Random.Range(90, 95)) - 32) * 5/9;
self.maxSummerTemp = ((Random.Range(95, 115)) - 32) * 5/9;
self.startingSummerTemp = (self.minSummerTemp + self.maxSummerTemp) / 2;
self.minFallTemp = ((Random.Range(50, 85)) - 32) * 5/9;
self.maxFallTemp = ((Random.Range(85, 90)) - 32) * 5/9;
self.startingFallTemp = (self.minFallTemp + self.maxFallTemp) / 2;
self.minWinterTemp = ((Random.Range(30, 40)) - 32) * 5/9;
self.maxWinterTemp = ((Random.Range(40, 50)) - 32) * 5/9;
self.startingWinterTemp = (self.minWinterTemp + self.maxWinterTemp) / 2;
}
}
EditorGUILayout.HelpBox("The Grassland Preset will generate a random Grassland like Climate according to real world data. \n\nThe Grassland climate consists of medium odds of precipitation mainly in the Spring and Summer months. The average temperature is hot during the Summer and cold during the Winter. Temperatures can exceed 100° during the summer months and fall as cold as 30° during the winter.\n\nAfter your climate has been generated, you can tweak the settings to your liking.", MessageType.None, true);
EditorGUILayout.Space();
if(GUILayout.Button("Reset to Default settings"))
{
self.weatherChanceSpring = 60;
self.weatherChanceSummer = 20;
self.weatherChanceFall = 40;
self.weatherChanceWinter = 80;
if (self.TemperatureType == 0)
{
self.minSpringTemp = 45;
self.maxSpringTemp = 65;
self.minSummerTemp = 70;;
self.maxSummerTemp = 100;
self.minFallTemp = 35;
self.maxFallTemp = 55;
self.minWinterTemp = 0;
self.maxWinterTemp = 40;
self.startingSpringTemp = 55;
self.startingSummerTemp = 85;
self.startingFallTemp = 45;
self.startingWinterTemp = 30;
}
if (self.TemperatureType == 1)
{
self.minSpringTemp = ((45) - 32) * 5/9;
self.maxSpringTemp = ((65) - 32) * 5/9;
self.minSummerTemp = ((70) - 32) * 5/9;
self.maxSummerTemp = ((100) - 32) * 5/9;
self.minFallTemp = ((35) - 32) * 5/9;
self.maxFallTemp = ((55) - 32) * 5/9;
self.minWinterTemp = ((0) - 32) * 5/9;
self.maxWinterTemp = ((40) - 32) * 5/9;
self.startingSpringTemp = ((55) - 32) * 5/9;
self.startingSummerTemp = ((85) - 32) * 5/9;
self.startingFallTemp = ((45) - 32) * 5/9;
self.startingWinterTemp = ((30) - 32) * 5/9;
}
}
EditorGUILayout.Space();
}
if (GUI.changed)
{
EditorUtility.SetDirty(self);
}
}
public float GetTempValueChanged(TemperatureType tempDisplayType, float value)
{
if (tempDisplayType == TemperatureType.Fahrenheit)
{
return value * 1.8f + 32;
}
else if (tempDisplayType == TemperatureType.Celsius)
{
return (value - 32) / 1.8f;
}
return value;
}