public static void InitSampleTower(int ID)
{
GameObject towerObj = (GameObject)Instantiate(buildManager.availableTowers[ID].gameObject);
buildManager.sampleTower.Add(towerObj.GetComponent <UnitTower>());
buildManager.sampleTower[buildManager.sampleTower.Count - 1].InitPerkParameters();
towerObj.transform.parent = buildManager.transform;
if (!buildManager.retainPrefabShaderForSamples)
{
UnitUtility.SetMat2AdditiveRecursively(buildManager.sampleTower[ID].thisT);
}
if (towerObj.collider != null)
{
Destroy(towerObj.collider);
}
UnitUtility.DestroyColliderRecursively(towerObj.transform);
//~ #if UNITY_4_0
//~ towerObj.SetActive(false);
//~ #else
//~ towerObj.SetActiveRecursively(false);
//~ #endif
Utility.SetActive(towerObj, false);
}
public DateTime GetMaxSyncStamp()
{
if (!ForceConnectionOpen())
{
throw new Exception("Could not open database.");
}
DateTime minStamp = default(DateTime);
using (var command = _connection.CreateTextCommand("SELECT stamp FROM syncstamps ORDER BY stamp DESC LIMIT 1")) {
using (var reader = command.ExecuteReader()) {
if (reader.Read())
{
minStamp = UnitUtility.ConvertFromPosixTime(reader.GetInt32(0));
}
}
}
if (default(DateTime).Equals(minStamp))
{
using (var command = _connection.CreateTextCommand("SELECT stamp FROM dayrecord ORDER BY stamp DESC LIMIT 1")) {
// todo: pull this from the 10minute instead?
using (var reader = command.ExecuteReader()) {
if (reader.Read())
{
minStamp = UnitUtility.ConvertFromPosixTime(reader.GetInt32(0));
}
}
}
}
return(minStamp);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="readings"></param>
/// <returns></returns>
/// <remarks>
/// Result is ordered by stamp in ascending order.
/// </remarks>
public static IEnumerable <ReadingsSummary> Summarize <T>(IEnumerable <T> readings, TimeUnit unit) where T : IReading
{
List <T> collectedReadings = new List <T>();
IEnumerator <T> enumerator = readings.GetEnumerator(); //readings.OrderBy(r => r.TimeStamp).GetEnumerator();
if (enumerator.MoveNext())
{
collectedReadings.Add(enumerator.Current);
DateTime dateRangeLow = UnitUtility.StripToUnit(enumerator.Current.TimeStamp, unit);
DateTime dateRangeHigh = UnitUtility.IncrementByUnit(dateRangeLow, unit);
while (enumerator.MoveNext())
{
if (enumerator.Current.TimeStamp < dateRangeHigh)
{
collectedReadings.Add(enumerator.Current);
}
else
{
yield return(FormSummary(dateRangeLow, dateRangeHigh, collectedReadings));
collectedReadings.Clear();
collectedReadings.Add(enumerator.Current);
dateRangeLow = UnitUtility.StripToUnit(enumerator.Current.TimeStamp, unit);
dateRangeHigh = UnitUtility.IncrementByUnit(dateRangeLow, unit);
}
}
if (collectedReadings.Count > 0)
{
yield return(FormSummary(dateRangeLow, dateRangeHigh, collectedReadings));
}
}
}
private void QueryThreadBody()
{
if (!_queryActive)
{
return;
}
int networkSize = 4;
var values = new PackedReadingValues[networkSize];
bool?usingDaqTemp = null;
int highestValid = -1;
var now = DateTime.Now;
var daqSafeTime = UnitUtility.StripToSecond(now);
for (int i = 0; i < values.Length; i++)
{
values[i] = QueryValues(i);
}
for (int i = 0; i < values.Length; i++)
{
if (!values[i].IsValid)
{
continue;
}
if (PackedValuesFlags.AnemTemperatureSource != (values[i].RawFlags & PackedValuesFlags.AnemTemperatureSource))
{
usingDaqTemp = true;
}
else if (!usingDaqTemp.HasValue)
{
usingDaqTemp = false;
}
highestValid = Math.Max(highestValid, i);
}
if (highestValid < 0)
{
highestValid = 3;
}
networkSize = highestValid + 1;
_lastClock = QueryAdjustedClock(0);
_daqStat = _lastDaqStatusQuery >= now?QueryStatus() : DaqStatusValues.Default;
for (int i = 0; i < values.Length; i++)
{
_sensors[i].HandleObservation(values[i], networkSize, daqSafeTime);
}
_networkSize = networkSize;
if (!_usingDaqTempUntil.HasValue || _usingDaqTempUntil.Value <= DateTime.Now)
{
_usingDaqTemp = usingDaqTemp;
_usingDaqTempUntil = null;
}
}
public IEnumerable <PackedReading> GetReadings(string sensor, DateTime from, TimeSpan span)
{
DateTime to = from.Add(span);
if (to < from)
{
DateTime s = to;
to = from;
from = s;
}
if (!ForceConnectionOpen())
{
throw new Exception("Could not open database.");
}
using (var command = _connection.CreateTextCommand(
"SELECT stamp,[values] FROM Record"
+ " INNER JOIN Sensor ON (Sensor.sensorId = Record.sensorId)"
+ " WHERE Sensor.nameKey = @sensorNameKey"
+ " AND Record.stamp >= @minPosixStamp"
+ " AND Record.stamp <= @maxPosixStamp"
+ " ORDER BY stamp " + ((span < TimeSpan.Zero) ? "DESC" : "ASC")
)) {
command.AddParameter("minPosixStamp", DbType.Int32, UnitUtility.ConvertToPosixTime(from));
command.AddParameter("maxPosixStamp", DbType.Int32, UnitUtility.ConvertToPosixTime(to));
command.AddParameter("sensorNameKey", DbType.String, sensor);
using (var reader = command.ExecuteReader()) {
int ordStamp = reader.GetOrdinal("stamp");
int ordValues = reader.GetOrdinal("values");
byte[] values = new byte[8];
const int chunkSize = 256;
bool isReading = true;
var cache = new List <PackedReading>(chunkSize);
while (isReading)
{
cache.Clear();
for (int i = 0; i < chunkSize; i++)
{
if (!reader.Read())
{
isReading = false;
break;
}
reader.GetBytes(ordValues, 0, values, 0, values.Length);
cache.Add(new PackedReading(
UnitUtility.ConvertFromPosixTime(reader.GetInt32(ordStamp)),
PackedReadingValues.ConvertFromPackedBytes(values, 0)
));
}
foreach (var item in cache)
{
yield return(item);
}
}
}
}
}
public virtual void Awake()
{
thisT = transform;
thisObj = gameObject;
HPAttribute.Init(thisT);
UnitUtility.DestroyColliderRecursively(thisT);
}
public virtual void Awake()
{
thisT = transform;
thisObj = gameObject;
//if(subClass==_UnitSubClass.Creep)
HPAttribute.Init(thisT, (int)subClass);
UnitUtility.DestroyColliderRecursively(thisT);
}
public void _ShowSampleTower(int ID)
{
if (currentSampleID == ID || currentBuildInfo == null)
{
return;
}
if (currentSampleID >= 0)
{
ClearSampleTower();
}
bool matched = false;
//~ foreach(_TowerType type in currentBuildInfo.buildableType){
//~ if(type==sampleTower[ID].type){
//~ matched=true;
//~ break;
//~ }
//~ }
foreach (TowerAvailability avai in currentBuildInfo.towerAvaiList)
{
if (avai.ID == sampleTower[ID].prefabID)
{
if (avai.enabledInLvl)
{
matched = true;
}
break;
}
}
if (!retainPrefabShaderForSamples)
{
if (matched)
{
UnitUtility.SetAdditiveMatColorRecursively(sampleTower[ID].thisT, Color.green);
}
else
{
UnitUtility.SetAdditiveMatColorRecursively(sampleTower[ID].thisT, Color.red);
}
}
currentSampleID = ID;
sampleTower[ID].thisT.position = currentBuildInfo.position;
//sampleTower[ID].thisObj.SetActiveRecursively(true);
//~ #if UNITY_4_0
//~ sampleTower[ID].thisObj.SetActive(true);
//~ #else
//~ sampleTower[ID].thisObj.SetActiveRecursively(true);
//~ #endif
Utility.SetActive(sampleTower[ID].thisObj, true);
GameControl.ShowIndicator(sampleTower[ID]);
}
public void Process(T readings)
{
// wind dir stuff
if (null != readings.Mean)
{
var speed = readings.Mean.WindSpeed;
if (!Double.IsNaN(speed))
{
var energy = speed * speed;
var power = energy * speed;
foreach (var set in readings.GetWindDirectionCounts())
{
if (0 == set.Value || 0 == set.Key || Double.IsNaN(set.Key))
{
continue;
}
var dirSlot = UnitUtility.WrapDegree(((int)((set.Key + _angleHalfStep) / _angleStep)) * _angleStep);
WindDirectionEnergy windDirEnrg;
var modEnergy = power * set.Value;
if (_directionLookup.TryGetValue(dirSlot, out windDirEnrg))
{
windDirEnrg.Frequency += set.Value;
windDirEnrg.Power += modEnergy;
}
}
}
}
// wind speed stuff
foreach (var set in readings.GetWindSpeedCounts())
{
if (/*0 == set.Value ||*/ Double.IsNaN(set.Key))
{
continue;
}
var speedBucket = ((int)((set.Key + _speedHalfStep) / _speedStep)) * _speedStep;
WindSpeedFrequency windSpeedFreq;
if (_speedLookup.TryGetValue(speedBucket, out windSpeedFreq))
{
windSpeedFreq.Frequency += set.Value;
}
else
{
_speedLookup.Add(speedBucket, new WindSpeedFrequency(speedBucket, set.Value));
}
}
_weibullCalcNeeded = true;
}
public void Init(Transform transform)
{
fullHP = Mathf.Max(0, fullHP);
HP = fullHP;
rootTransform = transform;
cam = Camera.main.transform;
if (overlayBase == null)
{
overlayBase = GameObject.CreatePrimitive(PrimitiveType.Plane).transform;
if (overlayHP)
{
overlayBase.position = overlayHP.position;
overlayBase.rotation = overlayHP.rotation;
}
UnitUtility.DestroyColliderRecursively(overlayBase);
overlayBase.renderer.enabled = false;
overlayBase.parent = transform;
neverShowBase = true;
}
offsetB = overlayBase.localPosition;
if (overlayHP)
{
scaleModifierH = UnitUtility.GetWorldScale(overlayHP).x *5;
}
if (overlayHP != null)
{
overlayHP.gameObject.layer = LayerManager.LayerOverlay();
overlayRendererH = overlayHP.renderer;
overlayHP.parent = overlayBase;
overlayScaleH = overlayHP.localScale;
offsetH = overlayHP.localPosition;
if (alwaysShowOverlay)
{
overlayRendererH.enabled = true;
}
}
if (alwaysShowOverlay)
{
overlayIsVisible = true;
}
}
GameObject buildHill()
{
float realPercentage = 100 / groundHeightInPercent;
transform.position = new Vector3(UnitUtility.centerWidth(), UnitUtility.centerHeight(), 100);
GameObject mainHill = Instantiate(hillPrefab, transform);
//groundFill = transform.Find("GroundFill").gameObject;
float groundHeight = UnitUtility.percentHeight(groundHeightInPercent);
mainHill.transform.position = new Vector3(UnitUtility.centerWidth(), -550 + transform.position.y, hillDepth);
mainHill.transform.localScale = new Vector3(Screen.width * 2, hillDepth, hillDepth);
Debug.Log("groundHeightInPercent: " + groundHeightInPercent);
return(mainHill);
}
private TimeRange PushReadings <T>(
IDbCommand command, IEnumerable <T> readings, Func <T, byte[]> conversion,
DbParameter stampParam, DbParameter valuesParam
)
where T : IReading
{
DateTime minStamp = new DateTime(9999, 1, 1);
DateTime maxStamp = new DateTime(0);
int counter = 0;
try {
command.Transaction = _connection.BeginTransaction();
foreach (var reading in readings)
{
stampParam.Value = UnitUtility.ConvertToPosixTime(reading.TimeStamp);
valuesParam.Value = conversion(reading);
command.ExecuteNonQuery();
counter++;
if (counter >= RecordBatchQuantity)
{
counter = 0;
command.Transaction.Commit();
command.Transaction = _connection.BeginTransaction();
}
if (reading.TimeStamp < minStamp)
{
minStamp = reading.TimeStamp;
}
if (reading.TimeStamp > maxStamp)
{
maxStamp = reading.TimeStamp;
}
}
if (command.Transaction != null)
{
command.Transaction.Commit();
}
}
catch (Exception ex) {
if (null != command.Transaction)
{
command.Transaction.Rollback();
}
}
return(new TimeRange(minStamp, maxStamp));
}
private bool UpdateSummaryRecords(TimeRange rangeCovered, string sensorName, int sensorId)
{
TimeRange tenMinuteAlignedRange = new TimeRange(
UnitUtility.StripToUnit(rangeCovered.Low, TimeUnit.TenMinutes),
UnitUtility.StripToUnit(rangeCovered.High, TimeUnit.TenMinutes) + TenMinutes
);
var minuteSummaries = StatsUtil.Summarize(
GetReadings(sensorName, tenMinuteAlignedRange.Low, tenMinuteAlignedRange.Span), TimeUnit.Minute
).ToList();
bool minsOk = PushSummaries(sensorId, "MinuteRecord", minuteSummaries, new PosixTimeRange(tenMinuteAlignedRange));
var tenMinuteSummaries = new List <ReadingsSummary>();
{
List <List <ReadingsSummary> > tenMinutePeriodSummaries = new List <List <ReadingsSummary> >();
List <ReadingsSummary> currentMinuteSummaries = new List <ReadingsSummary>();
foreach (ReadingsSummary minuteSummary in minuteSummaries)
{
if (currentMinuteSummaries.Count == 0 ||
PeriodTenMinutes(currentMinuteSummaries[0].BeginStamp).Equals(PeriodTenMinutes(minuteSummary.BeginStamp))
)
{
currentMinuteSummaries.Add(minuteSummary);
}
else
{
tenMinutePeriodSummaries.Add(currentMinuteSummaries);
currentMinuteSummaries = new List <ReadingsSummary>();
}
}
if (currentMinuteSummaries.Count > 0)
{
tenMinutePeriodSummaries.Add(currentMinuteSummaries);
}
foreach (List <ReadingsSummary> minutelyForCondensing in tenMinutePeriodSummaries)
{
ReadingsSummary summary = StatsUtil.Combine(minutelyForCondensing);
summary.BeginStamp = PeriodTenMinutes(summary.BeginStamp);
summary.EndStamp = summary.BeginStamp.Add(TenMinutes).AddTicks(-1);
tenMinuteSummaries.Add(summary);
}
}
bool tenMinsOk = PushSummaries(sensorId, "TenminuteRecord", tenMinuteSummaries, new PosixTimeRange(tenMinuteAlignedRange));
return(minsOk && tenMinsOk);
}
// Use this for initialization
void Start()
{
if (indicator == null)
{
indicator = (Transform)Instantiate(Resources.Load("AbilityIndicator", typeof(Transform)));
if (indicator == null)
{
Debug.Log("warning, no default indicator has been assigned for AbilityManager");
indicator.parent = transform;
}
}
int overlayLayer = LayerManager.LayerOverlay();
foreach (Ability ability in allAbilityList)
{
if (ability.indicator != null)
{
ability.indicator = (Transform)Instantiate(ability.indicator);
UnitUtility.DestroyColliderRecursively(ability.indicator);
Utility.SetActive(ability.indicator.gameObject, false);
Utility.SetLayerRecursively(ability.indicator, overlayLayer);
//Debug.Log("visualEffect: "+ability.ID);
//~ ability.indicator.gameObject.name=ability.name;
if (ability.autoScaleIndicator)
{
float scale = 2 * ability.aoeRange / 10;
ability.indicator.localScale = new Vector3(scale, 1, scale);
}
ability.indicator.gameObject.layer = overlayLayer;
ability.indicator.parent = transform;
}
if (ability.visualEffect != null)
{
ObjectPoolManager.New(ability.visualEffect, 1);
}
}
Utility.SetActive(indicator.gameObject, false);
indicator.gameObject.layer = LayerManager.LayerOverlay();
}
public void _ShowSampleTower(int ID)
{
if (currentSampleID == ID || currentBuildInfo == null)
{
return;
}
if (currentSampleID > 0)
{
ClearSampleTower();
}
bool matched = false;
foreach (_TowerType type in currentBuildInfo.buildableType)
{
if (type == sampleTower[ID].type)
{
matched = true;
break;
}
}
if (!retainPrefabShaderForSamples)
{
if (matched)
{
UnitUtility.SetAdditiveMatColorRecursively(sampleTower[ID].thisT, Color.green);
}
else
{
UnitUtility.SetAdditiveMatColorRecursively(sampleTower[ID].thisT, Color.red);
}
}
currentSampleID = ID;
sampleTower[ID].thisT.position = currentBuildInfo.position;
sampleTower[ID].thisObj.SetActiveRecursively(true);
GameControl.ShowIndicator(sampleTower[ID]);
}
public static IEnumerable <ReadingAggregate> AggregateMean <T>(IEnumerable <T> readings, TimeUnit unit)
where T : IReading
{
int count;
var enumerator = readings.OrderBy(r => r.TimeStamp).GetEnumerator();
if (!enumerator.MoveNext())
{
yield break;
}
var collectedReadings = new List <T> {
enumerator.Current
};
var dateRangeLow = UnitUtility.StripToUnit(enumerator.Current.TimeStamp, unit);
var dateRangeHigh = UnitUtility.IncrementByUnit(dateRangeLow, unit);
while (enumerator.MoveNext())
{
if (enumerator.Current.TimeStamp < dateRangeHigh)
{
collectedReadings.Add(enumerator.Current);
}
else
{
var values = AggregateMeanValues(collectedReadings, out count);
yield return(new ReadingAggregate(dateRangeLow, dateRangeHigh, values, count));
collectedReadings.Clear();
collectedReadings.Add(enumerator.Current);
dateRangeLow = UnitUtility.StripToUnit(enumerator.Current.TimeStamp, unit);
dateRangeHigh = UnitUtility.IncrementByUnit(dateRangeLow, unit);
}
}
if (collectedReadings.Count > 0)
{
var values = AggregateMeanValues(collectedReadings, out count);
yield return(new ReadingAggregate(dateRangeLow, dateRangeHigh, values, count));
}
}
public static void InitiateSampleTower()
{
buildManager.sampleTower = new UnitTower[buildManager.towers.Length];
for (int i = 0; i < buildManager.towers.Length; i++)
{
GameObject towerObj = (GameObject)Instantiate(buildManager.towers[i].gameObject);
buildManager.sampleTower[i] = towerObj.GetComponent <UnitTower>();
if (!buildManager.retainPrefabShaderForSamples)
{
UnitUtility.SetMat2AdditiveRecursively(buildManager.sampleTower[i].thisT);
}
if (towerObj.collider != null)
{
Destroy(towerObj.collider);
}
UnitUtility.DestroyColliderRecursively(towerObj.transform);
towerObj.SetActiveRecursively(false);
//UnitUtility.SetAdditiveMatColorRecursively(towerObj.transform, Color.green);
}
}
static public Vector3 GetTilePos(Transform basePlane, Vector3 hitPos)
{
//check if the row count is odd or even number
float remainderX = UnitUtility.GetWorldScale(basePlane).x *10 / _gridSize % 2;
float remainderZ = UnitUtility.GetWorldScale(basePlane).z *10 / _gridSize % 2;
//get the rotation offset of the plane
Quaternion rot = Quaternion.LookRotation(hitPos - basePlane.position);
//get the x and z distance from the centre of the plane in the baseplane orientation
//from this point on all x and z will be in reference to the basePlane orientation
float dist = Vector3.Distance(hitPos, basePlane.position);
float distX = Mathf.Sin((rot.eulerAngles.y - basePlane.rotation.eulerAngles.y) * Mathf.Deg2Rad) * dist;
float distZ = Mathf.Cos((rot.eulerAngles.y - basePlane.rotation.eulerAngles.y) * Mathf.Deg2Rad) * dist;
//get the sign (1/-1) of the x and y direction
float signX = distX != 0 ? distX / Mathf.Abs(distX) : 1;
float signZ = distZ != 0 ? distZ / Mathf.Abs(distZ) : 1;
//calculate the tile number selected in z and z direction
float numX = Mathf.Round((distX + (remainderX - 1) * (signX * _gridSize / 2)) / _gridSize);
float numZ = Mathf.Round((distZ + (remainderZ - 1) * (signZ * _gridSize / 2)) / _gridSize);
//calculate offset in x-axis,
float offsetX = -(remainderX - 1) * signX * _gridSize / 2;
float offsetZ = -(remainderZ - 1) * signZ * _gridSize / 2;
//get the pos and apply the offset
Vector3 p = basePlane.TransformDirection(new Vector3(numX, 0, numZ) * _gridSize);
p += basePlane.TransformDirection(new Vector3(offsetX, 0, offsetZ));
//set the position;
Vector3 pos = p + basePlane.position;
return(pos);
}
public bool PushSyncStamp(DateTime stamp)
{
return(PushSyncStamp(UnitUtility.ConvertToPosixTime(stamp)));
}
// Use this for initialization
void InitPlatform()
{
if (autoSearchForPlatform)
{
LayerMask mask = 1 << LayerManager.LayerPlatform();
Collider[] platformCols = Physics.OverlapSphere(Vector3.zero, Mathf.Infinity, mask);
platforms = new Transform[platformCols.Length];
for (int j = 0; j < platformCols.Length; j++)
{
platforms[j] = platformCols[j].transform;
}
}
buildPlatforms = new Platform[platforms.Length];
int i = 0;
foreach (Transform basePlane in platforms)
{
//if the platform object havent got a platform componet on it, assign it
Platform platform = basePlane.gameObject.GetComponent <Platform>();
if (platform == null)
{
platform = basePlane.gameObject.AddComponent <Platform>();
platform.buildableType = new _TowerType[7];
//by default, all tower type is builidable
platform.buildableType[0] = _TowerType.TurretTower;
platform.buildableType[1] = _TowerType.AOETower;
//~ platform.buildableType[2]=_TowerType.DirectionalAOETower;
platform.buildableType[3] = _TowerType.SupportTower;
//~ platform.buildableType[4]=_TowerType.ResourceTower;
//~ platform.buildableType[5]=_TowerType.Mine;
//~ platform.buildableType[6]=_TowerType.Block;
}
buildPlatforms[i] = platform;
//make sure the plane is perfectly horizontal, rotation around the y-axis is presreved
basePlane.eulerAngles = new Vector3(0, basePlane.rotation.eulerAngles.y, 0);
//adjusting the scale
float scaleX = Mathf.Floor(UnitUtility.GetWorldScale(basePlane).x *10 / gridSize) * gridSize * 0.1f;
float scaleZ = Mathf.Floor(UnitUtility.GetWorldScale(basePlane).z *10 / gridSize) * gridSize * 0.1f;
if (scaleX == 0)
{
scaleX = gridSize * 0.1f;
}
if (scaleZ == 0)
{
scaleZ = gridSize * 0.1f;
}
basePlane.localScale = new Vector3(scaleX, 1, scaleZ);
//adjusting the texture
if (autoAdjstTextureToGrid)
{
Material mat = basePlane.renderer.material;
float x = (UnitUtility.GetWorldScale(basePlane).x *10f) / gridSize;
float z = (UnitUtility.GetWorldScale(basePlane).z *10f) / gridSize;
mat.mainTextureOffset = new Vector2(0.5f, 0.5f);
mat.mainTextureScale = new Vector2(x, z);
}
//get the platform component, if any
//Platform p=basePlane.gameObject.GetComponent<Platform>();
//buildPlatforms[i]=new BuildPlatform(basePlane, p);
i++;
}
}
static public bool CheckBuildPoint(Vector3 pointer)
{
//if(currentBuildInfo!=null) return false;
BuildableInfo buildableInfo = new BuildableInfo();
//layerMask for platform only
LayerMask maskPlatform = 1 << LayerManager.LayerPlatform();
//layerMask for detect all collider within buildPoint
LayerMask maskAll = 1 << LayerManager.LayerPlatform();
if (buildManager.terrainColliderLayer >= 0)
{
maskAll |= 1 << buildManager.terrainColliderLayer;
}
Ray ray = Camera.main.ScreenPointToRay(pointer);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, Mathf.Infinity, maskPlatform))
{
for (int i = 0; i < buildManager.buildPlatforms.Length; i++)
{
Transform basePlane = buildManager.buildPlatforms[i].thisT;
if (hit.transform == basePlane)
{
//calculating the build center point base on the input position
//check if the row count is odd or even number
float remainderX = UnitUtility.GetWorldScale(basePlane).x *10 / _gridSize % 2;
float remainderZ = UnitUtility.GetWorldScale(basePlane).z *10 / _gridSize % 2;
//get the rotation offset of the plane
Quaternion rot = Quaternion.LookRotation(hit.point - basePlane.position);
//get the x and z distance from the centre of the plane in the baseplane orientation
//from this point on all x and z will be in reference to the basePlane orientation
float dist = Vector3.Distance(hit.point, basePlane.position);
float distX = Mathf.Sin((rot.eulerAngles.y - basePlane.rotation.eulerAngles.y) * Mathf.Deg2Rad) * dist;
float distZ = Mathf.Cos((rot.eulerAngles.y - basePlane.rotation.eulerAngles.y) * Mathf.Deg2Rad) * dist;
//get the sign (1/-1) of the x and y direction
float signX = distX / Mathf.Abs(distX);
float signZ = distZ / Mathf.Abs(distZ);
//calculate the tile number selected in z and z direction
float numX = Mathf.Round((distX + (remainderX - 1) * (signX * _gridSize / 2)) / _gridSize);
float numZ = Mathf.Round((distZ + (remainderZ - 1) * (signZ * _gridSize / 2)) / _gridSize);
//calculate offset in x-axis,
float offsetX = -(remainderX - 1) * signX * _gridSize / 2;
float offsetZ = -(remainderZ - 1) * signZ * _gridSize / 2;
//get the pos and apply the offset
Vector3 p = basePlane.TransformDirection(new Vector3(numX, 0, numZ) * _gridSize);
p += basePlane.TransformDirection(new Vector3(offsetX, 0, offsetZ));
//set the position;
Vector3 pos = p + basePlane.position;
//check if the position is blocked, by any other obstabcle other than the baseplane itself
Collider[] cols = Physics.OverlapSphere(pos, _gridSize / 2 * 0.9f, ~maskAll);
if (cols.Length > 0)
{
//Debug.Log("something's in the way "+cols[0]);
return(false);
}
else
{
//confirm that we can build here
buildableInfo.buildable = true;
buildableInfo.position = pos;
buildableInfo.platform = buildManager.buildPlatforms[i];
}
buildableInfo.buildableType = buildManager.buildPlatforms[i].buildableType;
buildableInfo.specialBuildableID = buildManager.buildPlatforms[i].specialBuildableID;
break;
}
}
}
else
{
return(false);
}
currentBuildInfo = buildableInfo;
if (buildManager.enableTileIndicator)
{
indicator.active = true;
indicator.transform.position = currentBuildInfo.position;
indicator.transform.rotation = currentBuildInfo.platform.thisT.rotation;
}
return(true);
}
//called to set indicator to a particular node, set the color as well
//not iOS performance friendly
static public void SetIndicator(Vector3 pointer)
{
if (!buildManager.enableTileIndicator)
{
return;
}
//layerMask for platform only
LayerMask maskPlatform = 1 << LayerManager.LayerPlatform();
//layerMask for detect all collider within buildPoint
LayerMask maskAll = 1 << LayerManager.LayerPlatform();
if (buildManager.terrainColliderLayer >= 0)
{
maskAll |= 1 << buildManager.terrainColliderLayer;
}
Ray ray = Camera.main.ScreenPointToRay(pointer);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, Mathf.Infinity, maskPlatform))
{
for (int i = 0; i < buildManager.buildPlatforms.Length; i++)
{
Transform basePlane = buildManager.buildPlatforms[i].thisT;
if (hit.transform == basePlane)
{
//calculating the build center point base on the input position
//check if the row count is odd or even number
float remainderX = UnitUtility.GetWorldScale(basePlane).x *10 / _gridSize % 2;
float remainderZ = UnitUtility.GetWorldScale(basePlane).z *10 / _gridSize % 2;
//get the rotation offset of the plane
Quaternion rot = Quaternion.LookRotation(hit.point - basePlane.position);
//get the x and z distance from the centre of the plane in the baseplane orientation
//from this point on all x and z will be in reference to the basePlane orientation
float dist = Vector3.Distance(hit.point, basePlane.position);
float distX = Mathf.Sin((rot.eulerAngles.y - basePlane.rotation.eulerAngles.y) * Mathf.Deg2Rad) * dist;
float distZ = Mathf.Cos((rot.eulerAngles.y - basePlane.rotation.eulerAngles.y) * Mathf.Deg2Rad) * dist;
//get the sign (1/-1) of the x and y direction
float signX = distX / Mathf.Abs(distX);
float signZ = distZ / Mathf.Abs(distZ);
//calculate the tile number selected in z and z direction
float numX = Mathf.Round((distX + (remainderX - 1) * (signX * _gridSize / 2)) / _gridSize);
float numZ = Mathf.Round((distZ + (remainderZ - 1) * (signZ * _gridSize / 2)) / _gridSize);
//calculate offset in x-axis,
float offsetX = -(remainderX - 1) * signX * _gridSize / 2;
float offsetZ = -(remainderZ - 1) * signZ * _gridSize / 2;
//get the pos and apply the offset
Vector3 p = basePlane.TransformDirection(new Vector3(numX, 0, numZ) * _gridSize);
p += basePlane.TransformDirection(new Vector3(offsetX, 0, offsetZ));
//set the position;
Vector3 pos = p + basePlane.position;
indicator2.active = true;
indicator2.transform.position = pos;
indicator2.transform.rotation = basePlane.rotation;
Collider[] cols = Physics.OverlapSphere(pos, _gridSize / 2 * 0.9f, ~maskAll);
if (cols.Length > 0)
{
indicator2.renderer.material.SetColor("_TintColor", Color.red);
}
else
{
indicator2.renderer.material.SetColor("_TintColor", Color.green);
}
}
}
}
else
{
indicator2.active = false;
}
}
private static ReadingsSummary FormSummary <T>(DateTime dateRangeLow, DateTime dateRangeHigh, List <T> readings) where T : IReadingValues
{
int tempCount = 0;
int presCount = 0;
int humCount = 0;
int speedCount = 0;
int dirCount = 0;
double tempSum = 0;
double presSum = 0;
double humSum = 0;
double speedSum = 0;
double dirSinSum = 0;
double dirCosSum = 0;
var tempCounts = new Dictionary <double, int>();
var presCounts = new Dictionary <double, int>();
var humCounts = new Dictionary <double, int>();
var speedCounts = new Dictionary <double, int>();
var dirCounts = new Dictionary <double, int>();
int count;
ReadingValues minValues;
ReadingValues maxValues;
ReadingValues meanValues;
ReadingValues sampleStandardDeviationValues;
if (readings.Count > 0)
{
minValues = new ReadingValues(readings[0]);
maxValues = new ReadingValues(readings[0]);
double value;
for (int i = 0; i < readings.Count; i++)
{
T reading = readings[i];
if (reading.IsTemperatureValid)
{
tempCount++;
value = reading.Temperature;
tempSum += value;
if (minValues.Temperature > value)
{
minValues.Temperature = value;
}
else if (maxValues.Temperature < value)
{
maxValues.Temperature = value;
}
value = Math.Round(value);
tempCounts[value] = tempCounts.TryGetValue(value, out count) ? count + 1 : 1;
}
if (reading.IsPressureValid)
{
presCount++;
value = reading.Pressure;
presSum += value;
if (minValues.Pressure > value)
{
minValues.Pressure = value;
}
else if (maxValues.Pressure < value)
{
maxValues.Pressure = value;
}
value = Math.Round(value);
presCounts[value] = presCounts.TryGetValue(value, out count) ? count + 1 : 1;
}
if (reading.IsHumidityValid)
{
humCount++;
value = reading.Humidity;
humSum += value;
if (minValues.Humidity > value)
{
minValues.Humidity = value;
}
else if (maxValues.Humidity < value)
{
maxValues.Humidity = value;
}
value = Math.Round(value);
humCounts[value] = humCounts.TryGetValue(value, out count) ? count + 1 : 1;
}
if (reading.IsWindSpeedValid)
{
speedCount++;
value = reading.WindSpeed;
speedSum += value;
if (minValues.WindSpeed > value)
{
minValues.WindSpeed = value;
}
else if (maxValues.WindSpeed < value)
{
maxValues.WindSpeed = value;
}
value = Math.Round(value * 2.0) / 2; // round to nearest .5
speedCounts[value] = speedCounts.TryGetValue(value, out count) ? count + 1 : 1;
}
if (reading.IsWindDirectionValid)
{
dirCount++;
value = reading.WindDirection;
//dirSum += value;
double dirRad = value * DegToRadFactor;
dirSinSum += Math.Sin(dirRad);
dirCosSum += Math.Cos(dirRad);
if (minValues.WindDirection > value)
{
minValues.WindDirection = value;
}
else if (maxValues.WindDirection < value)
{
maxValues.WindDirection = value;
}
value = Math.Round(value);
dirCounts[value] = dirCounts.TryGetValue(value, out count) ? count + 1 : 1;
}
}
meanValues = new ReadingValues(
tempCount == 0 ? Double.NaN : (tempSum / tempCount),
presCount == 0 ? Double.NaN : (presSum / presCount),
humCount == 0 ? Double.NaN : (humSum / humCount),
(dirCount == 0 || Double.IsNaN(dirSinSum) || Double.IsNaN(dirCosSum))
? Double.NaN
: UnitUtility.WrapDegree(Math.Atan2(dirSinSum / dirCount, dirCosSum / dirCount) * RadToDegFactor),
speedCount == 0 ? Double.NaN : (speedSum / speedCount)
);
sampleStandardDeviationValues = new ReadingValues(0, 0, 0, 0, 0);
for (int i = 0; i < readings.Count; i++)
{
T reading = readings[i];
if (reading.IsTemperatureValid)
{
value = reading.Temperature - meanValues.Temperature;
sampleStandardDeviationValues.Temperature += value * value;
}
if (reading.IsPressureValid)
{
value = reading.Pressure - meanValues.Pressure;
sampleStandardDeviationValues.Pressure += value * value;
}
if (reading.IsHumidityValid)
{
value = reading.Humidity - meanValues.Humidity;
sampleStandardDeviationValues.Humidity += value * value;
}
if (reading.IsWindSpeedValid)
{
value = reading.WindSpeed - meanValues.WindSpeed;
sampleStandardDeviationValues.WindSpeed += value * value;
}
if (reading.IsWindDirectionValid)
{
value = reading.WindDirection - meanValues.WindDirection;
sampleStandardDeviationValues.WindDirection += value * value;
}
}
sampleStandardDeviationValues.Temperature = Math.Sqrt(sampleStandardDeviationValues.Temperature / tempCount);
sampleStandardDeviationValues.Pressure = Math.Sqrt(sampleStandardDeviationValues.Pressure / presCount);
sampleStandardDeviationValues.Humidity = Math.Sqrt(sampleStandardDeviationValues.Humidity / humCount);
sampleStandardDeviationValues.WindSpeed = Math.Sqrt(sampleStandardDeviationValues.WindSpeed / speedCount);
sampleStandardDeviationValues.WindDirection = Math.Sqrt(sampleStandardDeviationValues.WindDirection / dirCount);
}
else
{
minValues = ReadingValues.CreateInvalid();
maxValues = ReadingValues.CreateInvalid();
meanValues = ReadingValues.CreateInvalid();
sampleStandardDeviationValues = ReadingValues.CreateInvalid();
}
return(new ReadingsSummary(
dateRangeLow,
dateRangeHigh.Subtract(new TimeSpan(1)),
minValues, maxValues,
meanValues, sampleStandardDeviationValues,
readings.Count,
tempCounts,
presCounts,
humCounts,
speedCounts,
dirCounts
));
}
public void SetValues(ISensor sensor, IReadingValues reading)
{
ReadingValuesConverter <IReadingValues, ReadingValues> converter = null;
if (null != sensor)
{
int n;
sensorNameLabel.Text = (Int32.TryParse(sensor.Name, out n) && 0 <= n && n < 26)
? ((char)((byte)('A') + (byte)n)).ToString()
: sensor.Name;
if (null != ConverterCache && sensor is ISensorInfo)
{
var si = sensor as ISensorInfo;
converter = ConverterCache.Get(
si.TemperatureUnit, TemperatureUnit,
si.SpeedUnit, SpeedUnit,
si.PressureUnit, PressureUnit
);
}
}
else
{
sensorNameLabel.Text = "Sensor";
}
const string na = "N/A";
if (null != reading && reading.IsValid)
{
var data = null == converter
? reading
: converter.Convert(reading)
;
string tempText;
if (data.IsTemperatureValid)
{
tempText = data.Temperature.ToString("F1") + ' ' + UnitUtility.GetFriendlyName(TemperatureUnit);
}
else
{
tempText = na;
}
string presText;
if (data.IsPressureValid)
{
var presUnit = PressureUnit;
presText = Math.Round(data.Pressure, presUnit == PressureUnit.Millibar ? 1 : 2).ToString()
+ ' '
+ UnitUtility.GetFriendlyName(presUnit)
;
}
else
{
presText = na;
}
string speedText;
if (data.IsWindSpeedValid)
{
speedText = data.WindSpeed.ToString("F2") + ' ' + UnitUtility.GetFriendlyName(SpeedUnit);
}
else
{
speedText = na;
}
string dirText;
if (data.IsWindDirectionValid)
{
dirText = Math.Round(data.WindDirection).ToString()
+ "\xb0 "
+ Vector2D.CardinalDirection.DegreesToBestCardinalName(reading.WindDirection)
;
}
else
{
dirText = na;
}
tempValue.Text = tempText;
pressureValue.Text = presText;
humidityValue.Text = data.IsHumidityValid
? (Math.Round(data.Humidity * 100.0, 1).ToString() + '%')
: na
;
windSpeedValue.Text = speedText;
windDirValue.Text = dirText;
}
else
{
tempValue.Text = na;
pressureValue.Text = na;
humidityValue.Text = na;
windSpeedValue.Text = na;
windDirValue.Text = na;
}
}
public static PackedReading GetCurrentReading(DateTime now, Random rand, IReadingValues lastReading)
{
double averagePressure = 1014.23;
double pressureRange = 100.0;
double pressure = (rand.NextDouble() * pressureRange) - (pressureRange / 2) + averagePressure;
double windDirectionRad = (rand.NextDouble() * Math.PI * 2.0);
//double windDirectionDeg = Vector2D.RadiansToDegrees(windDirectionRad);
//Vector2D windDirectionVec = new Vector2D((Math.Cos(windDirectionRad) * 2.0), (Math.Sin(windDirectionRad) * 2.0));
//double windDirectionDeg = windDirectionVec.GetNorthRelativeClockwiseAngularDegrees();
double averageWindSpeed = 9;
double averageTemp = 51.0;
double tempRange = 10.0;
double averageHumM = 79;
double averageHumA = 58;
switch (now.Month)
{
case 1: {
averageWindSpeed = 10.4;
averageTemp = 27.5;
averageHumM = 77;
averageHumA = 66;
break;
}
case 2: {
averageWindSpeed = 10.3;
averageTemp = 30.5;
averageHumM = 75;
averageHumA = 62;
break;
}
case 3: {
averageWindSpeed = 10.6;
averageTemp = 39.8;
averageHumM = 76;
averageHumA = 57;
break;
}
case 4: {
averageWindSpeed = 10.2;
averageTemp = 49.9;
averageHumM = 74;
averageHumA = 51;
break;
}
case 5: {
averageWindSpeed = 8.7;
averageTemp = 60.0;
averageHumM = 77;
averageHumA = 52;
break;
}
case 6: {
averageWindSpeed = 8;
averageTemp = 68.4;
averageHumM = 80;
averageHumA = 53;
break;
}
case 7: {
averageWindSpeed = 7.3;
averageTemp = 72.6;
averageHumM = 83;
averageHumA = 54;
break;
}
case 8: {
averageWindSpeed = 6.8;
averageTemp = 71;
averageHumM = 86;
averageHumA = 56;
break;
}
case 9: {
averageWindSpeed = 7.4;
averageTemp = 64.0;
averageHumM = 87;
averageHumA = 57;
break;
}
case 10: {
averageWindSpeed = 8.3;
averageTemp = 52.5;
averageHumM = 82;
averageHumA = 55;
break;
}
case 11: {
averageWindSpeed = 9.7;
averageTemp = 42.3;
averageHumM = 79;
averageHumA = 62;
break;
}
case 12: {
averageWindSpeed = 10.1;
averageTemp = 32.5;
averageHumM = 78;
averageHumA = 67;
break;
}
}
averageTemp = UnitUtility.ConvertUnit(averageTemp, TemperatureUnit.Fahrenheit, TemperatureUnit.Celsius);
tempRange = 4;
averageWindSpeed = UnitUtility.ConvertUnit(averageWindSpeed, SpeedUnit.MilesPerHour, SpeedUnit.MetersPerSec) * 4.0;
double humidityRange = Math.Abs(averageHumM - averageHumA) * 1.5;
double humidity = (humidityRange * rand.NextDouble()) - (humidityRange / 2.0) + ((averageHumM + averageHumA) / 2.0);
humidity /= 100.0;
double temp = (rand.NextDouble() * tempRange) - (tempRange / 2.0) + averageTemp;
double windSpeed = rand.NextDouble();
windSpeed = (windSpeed > 0.5) ? 0 : 4.0 * averageWindSpeed * windSpeed * windSpeed;
double windDirectionDeg = (((rand.NextDouble() * 360.0) * 4) + 90) / 5.0; // 4 parts random, 1 part 90 degrees
var newValues = new ReadingValues(
temp,
pressure,
humidity,
windDirectionDeg,
windSpeed
);
if (null != lastReading && lastReading.IsValid)
{
var readings = new[] { lastReading, lastReading, lastReading, newValues };
var meanCalc = new ReadingValuesMeanCalculator <IReadingValues>();
}
var stamp = now.Date.Add(new TimeSpan(now.Hour, now.Minute, now.Second));
return(new PackedReading(
stamp,
new PackedReadingValues(newValues)
));
}
private bool PushSummaries(int sensorId, string tableName, IEnumerable <ReadingsSummary> summaries, PosixTimeRange totalRange)
{
string insertCommandText = String.Format(
"INSERT INTO {0} (sensorId,stamp,minValues,maxValues,meanValues,stddevValues,recordCount,tempCount,pressCount,humCount,speedCount,dirCount)"
+ " VALUES (@sensorId,@stamp,@minValues,@maxValues,@meanValues,@stddevValues,@recordCount,@tempCount,@pressCount,@humCount,@speedCount,@dirCount)",
tableName
);
string deleteCommandText = String.Format(
"DELETE FROM {0} WHERE stamp >= @minStamp AND stamp <= @maxStamp AND sensorId = @sensorId",
tableName
);
using (var command = _connection.CreateTextCommand(deleteCommandText)) {
command.Transaction = _connection.BeginTransaction();
var sensorIdParam = command.AddParameter("sensorId", DbType.Int32, sensorId);
if (totalRange.Span != 0)
{
command.AddParameter("minStamp", DbType.Int32, totalRange.Low);
command.AddParameter("maxStamp", DbType.Int32, totalRange.High);
command.ExecuteNonQuery();
}
command.CommandText = insertCommandText;
var stampParam = command.AddParameter("stamp", DbType.Int32, null);
var minValuesParam = command.AddParameter("minValues", DbType.Binary, null);
minValuesParam.Size = 8;
var maxValuesParam = command.AddParameter("maxValues", DbType.Binary, null);
maxValuesParam.Size = 8;
var meanValuesParam = command.AddParameter("meanValues", DbType.Binary, null);
meanValuesParam.Size = 8;
var stddevValuesParam = command.AddParameter("stddevValues", DbType.Binary, null);
stddevValuesParam.Size = 8;
var recordCountParam = command.AddParameter("recordCount", DbType.Int32, null);
recordCountParam.ParameterName = "recordCount";
var tempCountParam = command.AddParameter("tempCount", DbType.Binary, null);
tempCountParam.Size = 0;
var pressCountParam = command.AddParameter("pressCount", DbType.Binary, null);
pressCountParam.Size = 0;
var humCountParam = command.AddParameter("humCount", DbType.Binary, null);
humCountParam.Size = 0;
var speedCountParam = command.AddParameter("speedCount", DbType.Binary, null);
speedCountParam.Size = 0;
var dirCountParam = command.AddParameter("dirCount", DbType.Binary, null);
dirCountParam.Size = 0;
int counter = 0;
foreach (var summary in summaries)
{
stampParam.Value = UnitUtility.ConvertToPosixTime(summary.BeginStamp);
minValuesParam.Value = PackedReadingValues.ConvertToPackedBytes(summary.Min);
maxValuesParam.Value = PackedReadingValues.ConvertToPackedBytes(summary.Max);
meanValuesParam.Value = PackedReadingValues.ConvertToPackedBytes(summary.Mean);
stddevValuesParam.Value = PackedReadingValues.ConvertToPackedBytes(summary.SampleStandardDeviation);
recordCountParam.Value = summary.Count;
byte[] data;
tempCountParam.Value =
data = PackedReadingValues.ConvertTemperatureCountsToPackedBytes(summary.TemperatureCounts);
tempCountParam.Size = data.Length;
pressCountParam.Value = data = PackedReadingValues.ConvertPressureCountsToPackedBytes(summary.PressureCounts);
pressCountParam.Size = data.Length;
humCountParam.Value = data = PackedReadingValues.ConvertHumidityCountsToPackedBytes(summary.HumidityCounts);
humCountParam.Size = data.Length;
speedCountParam.Value = data = PackedReadingValues.ConvertWindSpeedCountsToPackedBytes(summary.WindSpeedCounts);
speedCountParam.Size = data.Length;
dirCountParam.Value =
data = PackedReadingValues.ConvertWindDirectionCountsToPackedBytes(summary.WindDirectionCounts);
dirCountParam.Size = data.Length;
command.ExecuteNonQuery();
counter++;
if (counter >= RecordBatchQuantity)
{
counter = 0;
command.Transaction.Commit();
command.Transaction = _connection.BeginTransaction();
}
}
command.Transaction.Commit();
}
return(true);
}
public void Init(Transform transform, int subClass)
{
fullHPDefault = Mathf.Max(0, fullHPDefault);
fullShieldDefault = Mathf.Max(0, fullShieldDefault);
float globalModifierH = 1, globalModifierS = 1;
if (subClass == 1)
{
globalModifierH = GlobalStatsModifier.CreepHP;
globalModifierS = GlobalStatsModifier.CreepShield;
}
else if (subClass == 2)
{
globalModifierH = GlobalStatsModifier.TowerHP;
globalModifierS = GlobalStatsModifier.TowerShield;
}
fullHP = fullHPDefault * globalModifierH;
HP = fullHP;
fullShield = fullShieldDefault * globalModifierS;
shield = fullShield;
rootTransform = transform;
cam = Camera.main.transform;
if (overlayBase == null)
{
if (overlayHP)
{
overlayBase = GameObject.CreatePrimitive(PrimitiveType.Plane).transform;
overlayBase.position = overlayHP.position;
overlayBase.rotation = overlayHP.rotation;
}
else if (overlayShield)
{
overlayBase = GameObject.CreatePrimitive(PrimitiveType.Plane).transform;
overlayBase.position = overlayShield.position;
overlayBase.rotation = overlayShield.rotation;
}
else
{
return;
}
UnitUtility.DestroyColliderRecursively(overlayBase);
overlayBase.renderer.enabled = false;
overlayBase.parent = transform;
neverShowBase = true;
}
offsetB = overlayBase.localPosition;
if (overlayHP)
{
scaleModifierH = UnitUtility.GetWorldScale(overlayHP).x *5;
}
if (overlayShield)
{
scaleModifierS = UnitUtility.GetWorldScale(overlayShield).x *5;
}
if (overlayHP != null)
{
overlayHP.gameObject.layer = LayerManager.LayerOverlay();
overlayRendererH = overlayHP.renderer;
overlayHP.parent = overlayBase;
overlayScaleH = overlayHP.localScale;
offsetH = overlayHP.localPosition;
if (alwaysShowOverlay)
{
overlayRendererH.enabled = true;
}
else
{
overlayRendererH.enabled = false;
}
}
if (overlayShield != null)
{
overlayShield.gameObject.layer = LayerManager.LayerOverlay();
overlayRendererS = overlayShield.renderer;
overlayShield.parent = overlayBase;
overlayScaleS = overlayShield.localScale;
offsetS = overlayShield.localPosition;
if (alwaysShowOverlay)
{
overlayRendererS.enabled = true;
}
else
{
overlayRendererS.enabled = false;
}
}
if (alwaysShowOverlay)
{
overlayIsVisible = true;
}
}
private IEnumerable <T> GetPackedSummaries <T>(string sensor, DateTime from, TimeSpan span, string tableName)
where T : PackedReadingsSummary, new()
{
DateTime to = from.Add(span);
if (to < from)
{
DateTime s = to;
to = from;
from = s;
}
if (!ForceConnectionOpen())
{
throw new Exception("Could not open database.");
}
using (var command = _connection.CreateTextCommand(String.Format(
"SELECT stamp,minValues,maxValues,meanValues,stddevValues,recordCount"
+ ",tempCount,pressCount,humCount,speedCount,dirCount"
+ " FROM [{0}]"
+ " INNER JOIN Sensor ON (Sensor.sensorId = [{0}].sensorId)"
+ " WHERE Sensor.nameKey = @sensorNameKey"
+ " AND [{0}].stamp >= @minPosixStamp"
+ " AND [{0}].stamp < @maxPosixStamp"
+ " ORDER BY stamp " + ((span < TimeSpan.Zero) ? "DESC" : "ASC"),
tableName
))) {
command.AddParameter("minPosixStamp", DbType.Int32, UnitUtility.ConvertToPosixTime(from));
command.AddParameter("maxPosixStamp", DbType.Int32, UnitUtility.ConvertToPosixTime(to));
command.AddParameter("sensorNameKey", DbType.String, sensor);
using (IDataReader reader = command.ExecuteReader()) {
int ordStamp = reader.GetOrdinal("stamp");
int ordMinValues = reader.GetOrdinal("minValues");
int ordMaxValues = reader.GetOrdinal("maxValues");
int ordMeanValues = reader.GetOrdinal("meanValues");
int ordStddevValues = reader.GetOrdinal("stddevValues");
int ordRecordCount = reader.GetOrdinal("recordCount");
int ordTempCount = reader.GetOrdinal("tempCount");
int ordPressCount = reader.GetOrdinal("pressCount");
int ordHumCount = reader.GetOrdinal("humCount");
int ordSpeedCount = reader.GetOrdinal("speedCount");
int ordDirCount = reader.GetOrdinal("dirCount");
byte[] values = new byte[8];
//return ReadAsSensorReadings(reader);
while (reader.Read())
{
reader.GetBytes(ordMinValues, 0, values, 0, values.Length);
PackedReadingValues minValues = PackedReadingValues.ConvertFromPackedBytes(values);
reader.GetBytes(ordMaxValues, 0, values, 0, values.Length);
PackedReadingValues maxValues = PackedReadingValues.ConvertFromPackedBytes(values);
reader.GetBytes(ordMeanValues, 0, values, 0, values.Length);
PackedReadingValues meanValues = PackedReadingValues.ConvertFromPackedBytes(values);
reader.GetBytes(ordStddevValues, 0, values, 0, values.Length);
PackedReadingValues stddevValues = PackedReadingValues.ConvertFromPackedBytes(values);
var summary = new T {
BeginStamp = UnitUtility.ConvertFromPosixTime(reader.GetInt32(ordStamp)),
Min = minValues,
Max = maxValues,
Mean = meanValues,
SampleStandardDeviation = stddevValues,
Count = reader.GetInt32(ordRecordCount),
TemperatureCounts =
PackedReadingValues.PackedCountsToHashUnsigned16(reader.GetValue(ordTempCount) as byte[]),
PressureCounts =
PackedReadingValues.PackedCountsToHashUnsigned16(reader.GetValue(ordPressCount) as byte[]),
HumidityCounts =
PackedReadingValues.PackedCountsToHashUnsigned16(reader.GetValue(ordHumCount) as byte[]),
WindSpeedCounts =
PackedReadingValues.PackedCountsToHashUnsigned16(reader.GetValue(ordSpeedCount) as byte[]),
WindDirectionCounts =
PackedReadingValues.PackedCountsToHashUnsigned16(reader.GetValue(ordDirCount) as byte[])
};
yield return(summary);
}
}
}
}
public int SpecificUnitPower(UnitMarch unit)
{
return(UnitUtility.CalculateSpecificUnitPowerValue(unit, March));
}
public static ReadingsSummary Combine <TSummary>(List <TSummary> readings) where TSummary : IReadingsSummary
{
int totalTempCount = 0;
int totalPresCount = 0;
int totalHumCount = 0;
int totalSpeedCount = 0;
int totalDirCount = 0;
int totalRecordCount = 0;
DateTime minStamp = DateTime.MaxValue;
DateTime maxStamp = DateTime.MinValue;
double dirSinSum = 0;
double dirCosSum = 0;
var summary = new ReadingsSummary(
default(DateTime),
default(DateTime),
ReadingValues.CreateInvalid(),
ReadingValues.CreateInvalid(),
ReadingValues.CreateInvalid(),
ReadingValues.CreateInvalid(),
0,
new Dictionary <double, int>(),
new Dictionary <double, int>(),
new Dictionary <double, int>(),
new Dictionary <double, int>(),
new Dictionary <double, int>()
);
if (0 == readings.Count)
{
return(summary);
}
summary.Min = new ReadingValues(Double.MaxValue, Double.MaxValue, Double.MaxValue, Double.MaxValue, Double.MaxValue);
summary.Max = new ReadingValues(Double.MinValue, Double.MinValue, Double.MinValue, Double.MinValue, Double.MinValue);
summary.Mean = new ReadingValues(0, 0, 0, 0, 0);
summary.SampleStandardDeviation = new ReadingValues(0, 0, 0, 0, 0);
foreach (var reading in readings)
{
if (reading.BeginStamp < minStamp)
{
minStamp = reading.BeginStamp;
}
if (reading.EndStamp > maxStamp)
{
maxStamp = reading.EndStamp;
}
if (summary.Min.Temperature > reading.Min.Temperature)
{
summary.Min.Temperature = reading.Min.Temperature;
}
if (summary.Min.Pressure > reading.Min.Pressure)
{
summary.Min.Pressure = reading.Min.Pressure;
}
if (summary.Min.Humidity > reading.Min.Humidity)
{
summary.Min.Humidity = reading.Min.Humidity;
}
if (summary.Min.WindSpeed > reading.Min.WindSpeed)
{
summary.Min.WindSpeed = reading.Min.WindSpeed;
}
if (summary.Min.WindDirection > reading.Min.WindDirection)
{
summary.Min.WindDirection = reading.Min.WindDirection;
}
if (summary.Max.Temperature < reading.Max.Temperature)
{
summary.Max.Temperature = reading.Max.Temperature;
}
if (summary.Max.Pressure < reading.Max.Pressure)
{
summary.Max.Pressure = reading.Max.Pressure;
}
if (summary.Max.Humidity < reading.Max.Humidity)
{
summary.Max.Humidity = reading.Max.Humidity;
}
if (summary.Max.WindSpeed < reading.Max.WindSpeed)
{
summary.Max.WindSpeed = reading.Max.WindSpeed;
}
if (summary.Max.WindDirection < reading.Max.WindDirection)
{
summary.Max.WindDirection = reading.Max.WindDirection;
}
int localTempCount = AppendCounts(summary.TemperatureCounts, reading.GetTemperatureCounts());
int localPresCount = AppendCounts(summary.PressureCounts, reading.GetPressureCounts());
int localHumCount = AppendCounts(summary.HumidityCounts, reading.GetHumidityCounts());
int localSpeedCount = AppendCounts(summary.WindSpeedCounts, reading.GetWindSpeedCounts());
int localDirCount = AppendCounts(summary.WindDirectionCounts, reading.GetWindDirectionCounts());
totalTempCount += localTempCount;
totalPresCount += localPresCount;
totalHumCount += localHumCount;
totalSpeedCount += localSpeedCount;
totalDirCount += localDirCount;
totalRecordCount += reading.Count;
summary.Mean.Temperature += reading.Mean.Temperature * localTempCount;
summary.Mean.Pressure += reading.Mean.Pressure * localPresCount;
summary.Mean.Humidity += reading.Mean.Humidity * localHumCount;
summary.Mean.WindSpeed += reading.Mean.WindSpeed * localSpeedCount;
double dirRad = reading.Mean.WindDirection * DegToRadFactor;
dirSinSum += Math.Sin(dirRad) * localDirCount;
dirCosSum += Math.Cos(dirRad) * localDirCount;
}
if (0 != totalTempCount && 1 != totalTempCount)
{
summary.Mean.Temperature /= totalTempCount;
}
if (0 != totalPresCount && 1 != totalPresCount)
{
summary.Mean.Pressure /= totalPresCount;
}
if (0 != totalHumCount && 1 != totalHumCount)
{
summary.Mean.Humidity /= totalHumCount;
}
if (0 != totalSpeedCount && 1 != totalSpeedCount)
{
summary.Mean.WindSpeed /= totalSpeedCount;
}
summary.Mean.WindDirection = (totalDirCount == 0 || Double.IsNaN(dirSinSum) || Double.IsNaN(dirCosSum))
? Double.NaN
: UnitUtility.WrapDegree(Math.Atan2(dirSinSum / totalDirCount, dirCosSum / totalDirCount) * RadToDegFactor);
double dev;
foreach (var reading in readings)
{
int localTempCount = reading.GetTemperatureCounts().Sum(c => c.Value);
int localPresCount = reading.GetPressureCounts().Sum(c => c.Value);
int localHumCount = reading.GetHumidityCounts().Sum(c => c.Value);
int localSpeedCount = reading.GetWindSpeedCounts().Sum(c => c.Value);
int localDirCount = reading.GetWindDirectionCounts().Sum(c => c.Value);
dev = (reading.Mean.Temperature - summary.Mean.Temperature);
summary.SampleStandardDeviation.Temperature += (dev * dev) * localTempCount;
dev = (reading.Mean.Pressure - summary.Mean.Pressure);
summary.SampleStandardDeviation.Pressure += (dev * dev) * localPresCount;
dev = (reading.Mean.Humidity - summary.Mean.Humidity);
summary.SampleStandardDeviation.Humidity += (dev * dev) * localHumCount;
dev = (reading.Mean.WindSpeed - summary.Mean.WindSpeed);
summary.SampleStandardDeviation.WindSpeed += (dev * dev) * localSpeedCount;
dev = (reading.Mean.WindDirection - summary.Mean.WindDirection);
summary.SampleStandardDeviation.WindDirection += (dev * dev) * localDirCount;
}
if (0 != totalTempCount && 1 != totalTempCount)
{
summary.SampleStandardDeviation.Temperature = Math.Sqrt(summary.SampleStandardDeviation.Temperature / totalTempCount);
}
if (0 != totalPresCount && 1 != totalPresCount)
{
summary.SampleStandardDeviation.Pressure = Math.Sqrt(summary.SampleStandardDeviation.Pressure / totalPresCount);
}
if (0 != totalHumCount && 1 != totalHumCount)
{
summary.SampleStandardDeviation.Humidity = Math.Sqrt(summary.SampleStandardDeviation.Humidity / totalHumCount);
}
if (0 != totalSpeedCount && 1 != totalSpeedCount)
{
summary.SampleStandardDeviation.WindSpeed = Math.Sqrt(summary.SampleStandardDeviation.WindSpeed / totalSpeedCount);
}
if (0 != totalDirCount && 1 != totalDirCount)
{
summary.SampleStandardDeviation.WindDirection = Math.Sqrt(summary.SampleStandardDeviation.WindDirection / totalDirCount);
}
summary.Count = totalRecordCount;
summary.BeginStamp = minStamp;
summary.EndStamp = maxStamp;
return(summary);
}
