public void LoadFromINI()
{
var x = GetPrivateProfileString("Global", "CurrentPowerLevel", "", iniFileName);
if (!string.IsNullOrWhiteSpace(x))
{
this.CurrentPowerLevel = (PowerLevel)Enum.Parse(typeof(PowerLevel), x);
}
else
{
this._currentPowerLevel = PowerLevel.Low;
}
x = GetPrivateProfileString(string.Format("{0}-{1}", this.CurrentBand, this.CurrentTx), "CurrentTxPowerLow", "", iniFileName);
if (!string.IsNullOrWhiteSpace(x))
{
this._currentTxPowerLow = int.Parse(x);
}
x = GetPrivateProfileString(string.Format("{0}-{1}", this.CurrentBand, this.CurrentTx), "CurrentTxPowerMid", "", iniFileName);
if (!string.IsNullOrWhiteSpace(x))
{
this._currentTxPowerMid = int.Parse(x);
}
x = GetPrivateProfileString(string.Format("{0}-{1}", this.CurrentBand, this.CurrentTx), "CurrentTxPowerHigh", "", iniFileName);
if (!string.IsNullOrWhiteSpace(x))
{
this._currentTxPowerHigh = int.Parse(x);
}
ForceTXPowerLevelUpdate();
}
private bool SetTdpSimple(PowerLevel level)
{
var execRet = ExecNvmlProcedure(false, $"{nameof(SetTdpSimple)}({level})", () => {
var nvmlDevice = GetNvmlDevice();
uint minLimit = 0;
uint maxLimit = 0;
var ret = NvmlNativeMethods.nvmlDeviceGetPowerManagementLimitConstraints(nvmlDevice, ref minLimit, ref maxLimit);
if (ret != nvmlReturn.Success)
{
throw new NvmlException($"nvmlDeviceGetPowerManagementLimitConstraints", ret);
}
uint defaultLimit = 0;
ret = NvmlNativeMethods.nvmlDeviceGetPowerManagementDefaultLimit(nvmlDevice, ref defaultLimit);
if (ret != nvmlReturn.Success)
{
throw new NvmlException($"nvmlDeviceGetPowerManagementDefaultLimit", ret);
}
var limit = minLimit + (defaultLimit - minLimit) * GetUintFromPowerLevel(level) / 2;
var tdpPerc = (limit * 100.0 / defaultLimit);
return(SetTdp(nvmlDevice, tdpPerc, defaultLimit));
});
return(execRet);
}
private static void MessageHandler(object args)
{
if (args is SleepEvent)
{
SleepChangeEventHandler h = OnSleepChange;
if (h != null)
{
h((SleepEvent)args);
}
}
else if (args is PowerEvent)
{
PowerEvent pe = (PowerEvent)args;
PowerLevelChangeEventHandler h = OnPowerLevelChange;
s_CurrentPowerLevel = pe.Level;
if (h != null)
{
h(pe);
}
}
}
private bool SetTdpSimple(PowerLevel level)
{
try
{
uint minLimit = 0;
uint maxLimit = 0;
var ret = NvmlNativeMethods.nvmlDeviceGetPowerManagementLimitConstraints(_nvmlDevice, ref minLimit, ref maxLimit);
if (ret != nvmlReturn.Success)
{
throw new Exception($"NVML nvmlDeviceGetPowerManagementLimitConstraints failed with status: {ret}");
}
uint defaultLimit = 0;
ret = NvmlNativeMethods.nvmlDeviceGetPowerManagementDefaultLimit(_nvmlDevice, ref defaultLimit);
if (ret != nvmlReturn.Success)
{
throw new Exception($"NVML nvmlDeviceGetPowerManagementDefaultLimit failed with status: {ret}");
}
var limit = minLimit + (defaultLimit - minLimit) * GetUintFromPowerLevel(level) / 2;
var tdpPerc = (limit * 100.0 / defaultLimit);
return(SetTdp(tdpPerc, defaultLimit));
}
catch (Exception e)
{
Logger.ErrorDelayed("NVML", e.ToString(), _delayedLogging);
return(false);
}
}
public bool SetPowerTarget(PowerLevel level)
{
PowerLevel = level;
if (SetTdpSimple(level))
{
return(true);
}
switch (level)
{
case PowerLevel.Low:
PowerLevel = level;
return(SetPowerTarget(_minPowerLimit));
case PowerLevel.Medium:
PowerLevel = level;
return(SetPowerTarget((uint)Math.Round((_minPowerLimit + _defaultPowerLimit) / 2d)));
case PowerLevel.High:
PowerLevel = level;
return(SetPowerTarget(_defaultPowerLimit));
}
return(false);
}
public override int GetHashCode()
{
return(23 ^ Name.GetHashCode() ^
Slot.GetHashCode() ^
PowerLevel.GetHashCode() ^
Tier.GetHashCode() ^
ClassType.GetHashCode());
}
public static EncounterEnemy CreateEnemyOfSetPowerLevel(System.Type enemyType,PowerLevel powerLevel)
{
EncounterEnemy newEnemy=(EncounterEnemy)System.Activator.CreateInstance(enemyType);
newEnemy.CommonConstructor();
if (powerLevel == PowerLevel.Normal)
newEnemy.NormalConstructor();
if (powerLevel == PowerLevel.Tough)
newEnemy.ToughConstructor();
return newEnemy;
}
/// <summary>
/// Gets the <see cref="PowerLevel"/> entry associated to the given value.
/// </summary>
/// <param name="dumb"></param>
/// <param name="value">Value of the <see cref="PowerLevel"/> to retrieve.</param>
/// <returns>The <see cref="PowerLevel"/> entry associated to the given value, <code>PowerLevel.LEVEL.UNKNOWN</code> if the <paramref name="value"/> could not be found in the list.</returns>
public static PowerLevel Get(this PowerLevel dumb, byte value)
{
var values = Enum.GetValues(typeof(PowerLevel)).OfType <PowerLevel>();
if (values.Cast <byte>().Contains(value))
{
return((PowerLevel)value);
}
return(PowerLevel.LEVEL_UNKNOWN);
}
// percent is in hundreds, e.g. 100%
public bool SetPowerTarget(double percent)
{
if (DeviceMonitorManager.DisableDevicePowerModeSettings)
{
Logger.InfoDelayed(LogTag, $"SetPowerTarget Disabled DeviceMonitorManager.DisableDevicePowerModeSettings==true", TimeSpan.FromSeconds(30));
return(false);
}
// TODO this Custom thingh shouild be changed so each mode has a custom setting
PowerLevel = PowerLevel.Custom;
return(SetTdpPercentage(percent));
}
public bool SetPowerTarget(PowerLevel level)
{
if (DeviceMonitorManager.DisableDevicePowerModeSettings)
{
Logger.InfoDelayed(LogTag, $"SetPowerTarget Disabled DeviceMonitorManager.DisableDevicePowerModeSettings==true", TimeSpan.FromSeconds(30));
return(false);
}
PowerLevel = level;
return(SetTdpSimple(level));
}
public void Shoot(int pow)
{
PowerLevel shotPower = PowerLevel.one;
GameObject temp;
if (pow >= 3)
{
shotPower = PowerLevel.super;
}
else if (pow >= 2)
{
shotPower = PowerLevel.three;
}
else if (pow >= 1)
{
shotPower = PowerLevel.two;
}
else
{
shotPower = PowerLevel.one;
}
switch (shotPower)
{
case PowerLevel.one:
temp = Instantiate(bullet1, forwardHolder);
temp.GetComponent <Rigidbody2D>().AddForce(forward * bulletForce * 200);
temp.transform.SetParent(GameObject.Find("Independent").transform);
break;
case PowerLevel.two:
temp = Instantiate(bullet2, transform.position, forwardHolder.transform.rotation);
temp.GetComponent <Rigidbody2D>().AddForce(forward * bulletForce * 200);
temp.transform.SetParent(GameObject.Find("Independent").transform);
break;
case PowerLevel.three:
temp = Instantiate(bullet3, transform.position, forwardHolder.transform.rotation);
temp.GetComponent <Rigidbody2D>().AddForce(forward * bulletForce * 200);
temp.transform.SetParent(GameObject.Find("Independent").transform);
break;
case PowerLevel.super:
temp = Instantiate(bulletSuper, transform.position, forwardHolder.transform.rotation);
temp.GetComponent <Rigidbody2D>().AddForce(forward * bulletForce * 200);
temp.transform.SetParent(GameObject.Find("Independent").transform);
break;
default:
break;
}
}
private static uint GetUintFromPowerLevel(PowerLevel powerLevel)
{
switch (powerLevel)
{
case PowerLevel.Low: return(0);
case PowerLevel.Medium: return(1);
case PowerLevel.High: return(2);
default: throw new Exception("GetUintFromPowerLevel - Unknown PowerLevel");
}
}
private void Update()
{
m_CurrentLevel = m_HI5Status.GetPowerLevel(m_Type);
if (m_HI5Status.IsGloveAvailable(m_Type))
{
SetPowerLevelSpriteRenderer(m_CurrentLevel);
}
else
{
SetPowerLevelSpriteRenderer(PowerLevel.Unknown);
}
}
private static void SetPowerMode(string device, PowerLevel level)
{
var devs = device == "*" ?
AvailableDevices.Devices :
AvailableDevices.Devices.Where(d => d.B64Uuid == device);
var found = devs.Count() > 0;
var hasEnabled = false;
var setSuccess = new List <bool>();
foreach (var dev in devs)
{
if (!dev.Enabled)
{
continue;
}
if (!dev.CanSetPowerMode)
{
continue;
}
hasEnabled = true;
// TODO check if set
var result = dev.SetPowerMode(level);
setSuccess.Add(result);
}
if (setSuccess.Any(t => t) && !setSuccess.All(t => t))
{
throw new RpcException("Not able to set power modes for all devices", ErrorCode.UnableToHandleRpc);
}
if (found && !hasEnabled)
{
throw new RpcException("No settable devices found", ErrorCode.UnableToHandleRpc);
}
if (!found)
{
throw new RpcException("No settable devices found", ErrorCode.UnableToHandleRpc);
}
}
private void SetPowerLevelSpriteRenderer(PowerLevel level)
{
switch (level)
{
case PowerLevel.Unknown:
m_SpritRenderer.sprite = null;
break;
case PowerLevel.Full:
m_SpritRenderer.sprite = m_Full;
break;
case PowerLevel.Normal:
m_SpritRenderer.sprite = m_Normal;
break;
case PowerLevel.Low:
m_SpritRenderer.sprite = m_Low;
break;
}
}
private IEnumerator AllowPowerUsers(Permissions permission, PowerLevel power, string errorIfNotAllowed)
{
ActionAllowed allowed = ActionAllowed.Unfinished;
yield return(null);
yield return(new object[]
{
permission.ToString(),
new Action(() => allowed = ActionAllowed.Allowed),
new Action(() => allowed = ActionAllowed.Denied)
});
yield return(null);
DebugLog("Permission = {0}, Result = {1}", permission, allowed);
if (allowed == ActionAllowed.Allowed)
{
yield break;
}
allowed = ActionAllowed.Unfinished;
yield return(new object[]
{
EnumUtils.StringValueOf(power),
new Action(() => allowed = ActionAllowed.Allowed),
new Action(() => allowed = ActionAllowed.Denied)
});
yield return(null);
DebugLog("Power override {0}, Result = {1}", power, allowed);
if (allowed == ActionAllowed.Allowed)
{
yield break;
}
Audio.PlayGameSoundAtTransform(KMSoundOverride.SoundEffect.Strike, transform);
yield return("sendtochaterror " + errorIfNotAllowed);
}
PowerLevel DisplayLevelForm(string label, PowerLevel data, ref bool foldout)
{
PowerLevel newData = data;
foldout = EditorGUILayout.Foldout(foldout, label + " : " + newData.Name);
if (foldout)
{
newData.Name = EditorGUILayout.TextField("Name", newData.Name);
GUILayout.Space(5);
EditorGUILayout.BeginHorizontal();
DisplayIndividualForm("Clover", ref newData.CloverDescription, ref newData.CloverEffectValue);
DisplayIndividualForm("Amaranth", ref newData.AmaranthDescription, ref newData.AmaranthEffectValue);
EditorGUILayout.EndHorizontal();
newData.CostMultiplier = EditorGUILayout.FloatField("Cost Multiplier", newData.CostMultiplier);
newData.VitaePrice = EditorGUILayout.IntField("Price (Vitae)", newData.VitaePrice);
}
return(newData);
}
/// <summary>
/// The ChangePowerLevel method enables the caller to adjust the current power level of the device.
/// The behavior of the power levels are determined by the hardware vendor. This method raises the
/// OnPowerLevelChange event.
/// </summary>
/// <param name="level">Describes the power level for which the system should enter</param>
public static void ChangePowerLevel(PowerLevel level)
{
if (s_CurrentPowerLevel == level)
{
return;
}
PowerLevelChangeEventHandler h = OnPowerLevelChange;
if (h != null)
{
PowerEvent e = new PowerEvent();
e.EventType = PowerEventType.PreNotify;
e.Level = level;
e.Time = DateTime.UtcNow;
h(e);
}
InternalChangePowerLevel(level);
s_CurrentPowerLevel = level;
}
extern private static void InternalChangePowerLevel(PowerLevel level);
// percent is in hundreds, e.g. 100%
public bool SetPowerTarget(double percent)
{
PowerLevel = PowerLevel.Custom;
return(SetPowerTarget((uint)Math.Round(percent * 1000)));
}
private static extern void SetLevel(PowerLevel powerLevel, PowerWakeSource wakeSource, ulong data);
/// <summary>
/// Sets the output power level at which this XBee device transmits conducted power.
/// </summary>
/// <param name="powerLevel">The new output power level to be set in this XBee device.</param>
/// <exception cref="ArgumentException">If <paramref name="powerLevel"/>
/// is <see cref="PowerLevel.LEVEL_UNKNOWN"/>.</exception>
/// <exception cref="InterfaceNotOpenException">If this device connection is not open.</exception>
/// <exception cref="TimeoutException">If there is a timeout setting the power level command.</exception>
/// <exception cref="XBeeException">If there is any other XBee related error.</exception>
/// <seealso cref="GetPowerLevel"/>
/// <seealso cref="PowerLevel"/>
public new void SetPowerLevel(PowerLevel powerLevel)
{
base.SetPowerLevel(powerLevel);
}
private static void MessageHandler(object args)
{
if (args is SleepEvent)
{
SleepChangeEventHandler h = OnSleepChange;
if (h != null)
{
h((SleepEvent)args);
}
}
else if (args is PowerEvent)
{
PowerEvent pe = (PowerEvent)args;
PowerLevelChangeEventHandler h = OnPowerLevelChange;
s_CurrentPowerLevel = pe.Level;
if (h != null)
{
h(pe);
}
}
}
extern private static void InternalChangePowerLevel(PowerLevel level);
public static string ToDisplayString(this PowerLevel source)
{
return(string.Format("{0}: {1}", HexUtils.ByteToHexString((byte)source), lookupTable[source]));
}
/**
* Sets the output power level at which this XBee device transmits
* conducted power.
*
* @param powerLevel The new output power level to be set in this XBee
* device.
*
* @throws InterfaceNotOpenException if this device connection is not open.
* @throws ArgumentNullException if {@code powerLevel == null}.
* @throws TimeoutException if there is a timeout setting the power level.
* @throws XBeeException if there is any other XBee related exception.
*
* @see #getPowerLevel()
* @see com.digi.xbee.api.models.PowerLevel
*/
public void SetPowerLevel(PowerLevel powerLevel)/*throws TimeoutException, XBeeException */{
if (powerLevel == null)
throw new ArgumentNullException("Power level cannot be null.");
SetParameter("PL", ByteUtils.IntToByteArray(powerLevel.GetValue()));
}
/// <summary>
/// Gets the power level value.
/// </summary>
/// <param name="source"></param>
/// <returns>The power level value.</returns>
public static byte GetValue(this PowerLevel source)
{
return((byte)source);
}
/// <summary>
/// Gets the power level description.
/// </summary>
/// <param name="source"></param>
/// <returns>The power level description.</returns>
public static string GetDescription(this PowerLevel source)
{
return(lookupTable[source]);
}
/// <summary>
/// The ChangePowerLevel method enables the caller to adjust the current power level of the device.
/// The behavior of the power levels are determined by the hardware vendor. This method raises the
/// OnPowerLevelChange event.
/// </summary>
/// <param name="level">Describes the power level for which the system should enter</param>
public static void ChangePowerLevel(PowerLevel level)
{
if (s_CurrentPowerLevel == level) return;
PowerLevelChangeEventHandler h = OnPowerLevelChange;
if (h != null)
{
PowerEvent e = new PowerEvent();
e.EventType = PowerEventType.PreNotify;
e.Level = level;
e.Time = DateTime.UtcNow;
h(e);
}
InternalChangePowerLevel(level);
s_CurrentPowerLevel = level;
}
