public async Task <IActionResult> Edit(int id, [Bind("EnergyTypeID,EnergyTypeName,LastUpdateDate")] EnergyType energyType)
{
if (id != energyType.EnergyTypeID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(energyType);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EnergyTypeExists(energyType.EnergyTypeID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(energyType));
}
public Segment(int min, int split, int max, EnergyType energy)
{
Min = min;
Split = split;
Max = max;
Energy = energy;
}
public bool DeepEquals(InventoryItemPlugBlockEnergyCapacity other)
{
return(other != null &&
CapacityValue == other.CapacityValue &&
EnergyType.DeepEquals(other.EnergyType) &&
EnergyTypeEnumValue == other.EnergyTypeEnumValue);
}
public IEnergyPart Create(EnergyType type, double directionX, double directionY, double directionZ,
IColor color, double value, string region)
{
IGraphicsObject graphic = _creator.CreateGraphic(type, value, directionX, directionY, directionZ, color);
return(new EnergyPart(graphic, region, value));
}
public bool DeepEquals(InventoryItemPlugBlockEnergyCost other)
{
return(other != null &&
EnergyCost == other.EnergyCost &&
EnergyType.DeepEquals(other.EnergyType) &&
EnergyTypeEnumValue == other.EnergyTypeEnumValue);
}
public bool Equals(DestinyItemInstanceEnergy input)
{
if (input == null)
{
return(false);
}
return
((
EnergyTypeHash == input.EnergyTypeHash ||
(EnergyTypeHash.Equals(input.EnergyTypeHash))
) &&
(
EnergyType == input.EnergyType ||
(EnergyType != null && EnergyType.Equals(input.EnergyType))
) &&
(
EnergyCapacity == input.EnergyCapacity ||
(EnergyCapacity.Equals(input.EnergyCapacity))
) &&
(
EnergyUsed == input.EnergyUsed ||
(EnergyUsed.Equals(input.EnergyUsed))
) &&
(
EnergyUnused == input.EnergyUnused ||
(EnergyUnused.Equals(input.EnergyUnused))
));
}
/// <summary>
/// For the remaining bins, compute the best energy distribution and the worst energy distribution
/// The best energy distribution:
/// - make the distances as equal as possible;
/// - some of them will be 'ave' and the rest will be 'ave+1'
/// The worst energy distribution:
/// - all except one distance will be 1
/// </summary>
private void GetEnergyBounds(int row, int col, EnergyType cur, out EnergyType best, out EnergyType worst)
{
Contracts.Assert(0 <= row && row < CountBins - 1);
Contracts.Assert(0 <= col && col <= _cskip);
// The distance to span.
int span = _accum[CountValues] - _accum[row + 1 + col];
// The number of remaining bins.
int cbin = CountBins - row - 1;
Contracts.Assert(0 < cbin && cbin <= span);
// Best case is that the remaining pegs are all equally spaced. Of course, they have
// to be spaced integer distances apart.
int ave = span / cbin;
int rem = span - ave * cbin;
Contracts.Assert(0 <= rem && rem < cbin);
best = cbin * Square(ave);
if (rem > 0)
{
best += rem * (2 * ave + 1);
}
best += cur;
// Worst case is all 1's except for one big bin.
int ones = cbin - 1;
worst = Square(span - ones) + ones;
worst += cur;
Contracts.Assert(worst >= best);
}
/// <summary>
/// 获取能源结算用量汇总
/// </summary>
/// <param name="year">年度</param>
/// <param name="energyType">能源类型</param>
/// <param name="department">部门</param>
/// <returns></returns>
public SettlementQuantumSummary GetDepartmentQuantumSummary(int year, EnergyType energyType, Department department)
{
SettlementQuantumSummary summary = new SettlementQuantumSummary();
summary.DepartmentName = department.Name;
summary.Year = year;
summary.EnergyType = energyType.DisplayName();
SettlementRecordBusiness srBusiness = new SettlementRecordBusiness();
var settlements = FindByYear(year).ToList();
if (settlements.Count == 0)
{
return(null);
}
bool flag = false;
for (int i = 0; i < settlements.Count; i++)
{
var settle = settlements[i];
var record = srBusiness.FindByDepartment(settle.Id, department.Id, energyType);
if (record == null)
{
continue;
}
switch (i)
{
case 0:
summary.PlanQuantum = record.BeginQuantum;
summary.FirstQuarter = record.Quantum;
break;
case 1:
summary.SecondQuarter = record.Quantum;
break;
case 2:
summary.ThirdQuarter = record.Quantum;
break;
case 3:
summary.FourthQuarter = record.Quantum;
break;
}
flag = true;
}
summary.TotalQuantum = summary.FirstQuarter + summary.SecondQuarter + summary.ThirdQuarter + summary.FourthQuarter;
summary.RemainQuantum = summary.PlanQuantum - summary.TotalQuantum;
if (!flag)
{
return(null);
}
return(summary);
}
void DrawEnergy(EnergyEmitter emitter)
{
var receivedEnergy = emitter.TransmitEnergy();
EnergyType energyType = emitter.GetEnergyType();
energyReceiver.AddEnergy(receivedEnergy, energyType);
heatEffects.AddEnergy(receivedEnergy, energyType);
}
public void AddEnergyPart(IEnergy energy, EnergyType type, double directionX, double directionY
, double directionZ, IColor color, double value, string region)
{
var energyPart = _creator.Create(type, directionX, directionY, directionZ, color, value
, region);
AddEnergyPart(energy, energyPart);
}
/// <summary>
/// 设置部门
/// </summary>
/// <param name="department">部门</param>
/// <param name="energyType">能源类型</param>
public void SetDepartment(Department department, EnergyType energyType)
{
this.currentDepartment = department;
this.energyType = energyType;
this.nowYear = DateTime.Now.Year;
LoadData(this.cmbPeriod.SelectedIndex, this.chkShowAmount.Checked);
}
public Personality(MindType mind, EnergyType energy, NatureType nature, TacticType tactics, IdentityType identity)
{
Mind = mind;
Energy = energy;
Nature = nature;
Tactics = tactics;
Identity = identity;
}
public async Task AddCrystal(EnergyType type)
{
if (crystals.Count >= maxCrystals)
{
return;
}
await GameController.Events.CallEvent(new GameEvents.OnAddCrystal(type, this));
}
public static string GetWeaponEnergyKey(EnergyType type)
{
if (type == EnergyType.Unlimited || type == EnergyType.NumTypes)
{
return(null);
}
return(weaponEnergyPrefix + ((int)type));
}
/// <summary>
/// 设置分组
/// </summary>
/// <param name="year"></param>
/// <param name="group"></param>
/// <param name="energyType"></param>
public void SetGroup(int year, Group group, EnergyType energyType)
{
this.currentGroup = group;
this.energyType = energyType;
this.showType = 2;
this.selectYear = year;
LoadGroupData(this.cmbType.SelectedIndex);
}
/// <summary>
/// 设置部门
/// </summary>
/// <param name="department">部门</param>
/// <param name="energyType">能源类型</param>
public void SetDepartment(Department department, EnergyType energyType)
{
this.currentDepartment = department;
this.energyType = energyType;
this.nowYear = DateTime.Now.Year;
this.showType = 1;
LoadDepartmentData(this.cmbType.SelectedIndex);
}
protected override void InitializeExecute()
{
base.InitializeExecute();
BusyCount++;
var parameters = NavigationProvider.GetNavigationParameters();
if (parameters.ContainsKey(Constants.NavigationParameters.EnergyType))
{
energyType = (EnergyType)Enum.Parse(typeof(EnergyType), parameters[Constants.NavigationParameters.EnergyType], true);
LoadDataForToday();
}
}
public Car(string maker, string model, EnergyType energyType, decimal pricePerDay, int maxKmsPerDay, decimal pricePerExtraKm, decimal depositFee, bool isAvailable = false, string id = null)
: this(id) // to call the parameterless constructor which will default some properties.
{
this.maker = maker;
this.model = model;
this.energyType = energyType;
this.pricePerDay = pricePerDay;
this.maxKmsPerDay = maxKmsPerDay;
this.pricePerExtraKm = pricePerExtraKm;
this.depositFee = depositFee;
}
private void SetupEnergyFunction()
{
if (energyClassJobTypes.Contains(Core.Player.CurrentJob))
{
CurrentEnergyType = EnergyType.TP;
}
else
{
CurrentEnergyType = EnergyType.MP;
}
}
public async Task <IActionResult> Create([Bind("EnergyTypeID,EnergyTypeName,LastUpdateDate")] EnergyType energyType)
{
if (ModelState.IsValid)
{
_context.Add(energyType);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(energyType));
}
public override void SpawnEnergy(int energyIndex, Vector3 position, int playerId)
{
EnergyType energyType = _energyTypes[energyIndex];
GameObject energy = GameObject.Instantiate(energyPrefab, position, Quaternion.identity);
EnergyView energyView = energy.GetComponent <EnergyView>();
energyView.SetOwningPlayer(playerId);
energyView.SetSpeed(energyType.GetSpeed());
}
protected override void InitializeExecute()
{
base.InitializeExecute();
var parameters = NavigationProvider.GetNavigationParameters();
fromPlan = parameters.ContainsKey(Constants.NavigationParameters.FromPlan);
if (parameters.ContainsKey(Constants.NavigationParameters.EnergyType))
{
searchType = (EnergyType) Enum.Parse(typeof(EnergyType), parameters[Constants.NavigationParameters.EnergyType], true);
GetTop();
}
}
override public void AddEnergy(float addedEnergy, EnergyType energyType)
{
if (energyType == EnergyType.Sunlight)
{
UpdateHeat(addedEnergy);
}
else if (energyType == EnergyType.Rain)
{
UpdateHeat(-addedEnergy);
}
energy += addedEnergy;
}
private Vehicle getOwnerVehicle()
{
Vehicle.eVehicleType vehicleType = getVehicleType();
string vehicleModel = getVehicleModel();
string licensePlate = getLicensePlate();
EnergyType energyType = getEnergyType(vehicleType);
Wheel wheel = getWheelData(vehicleType);
Vehicle ownerVehicle = VehicleInitializer.CreateNewVehicle(vehicleType, vehicleModel, licensePlate, energyType, wheel);
updateVehicleInnerData(ownerVehicle);
return(ownerVehicle);
}
public ActionResult GetPolygon(EnergyType type)
{
var polygons = db.Areas
.Where(x => x.Type == type)
.Select(x => new ViewArea
{
Id = x.Id,
Type = x.Type,
Rate = x.Rate,
Points = x.Polygon,
});
return Json(polygons, JsonRequestBehavior.AllowGet);
}
public virtual void ChangeHealth(float change, EnergyType energyType)
{
Debug.Log(transform.name + " Take " + change + " hpchange from " + energyType);
float damage = CalculateResistence(change, energyType);
if (damage < 0)
{
_anim.SetTrigger("Hurt");
}
Debug.Log(transform.name + " Get " + damage + " hp");
HealthActual += damage;
}
private static int GetBitwiseFlag(MindType mind, EnergyType energy, NatureType nature, TacticType tactics, IdentityType identity)
{
// 0x00000000
int bits = 0b00000;
bits |= (int)mind
| (int)nature
| (int)energy
| (int)tactics
| (int)identity;
return(bits);
}
// Set the multiplier for the given energy type
// If no intake info exists with the given type, add one to the list
public void SetIntakeMultiplier(EnergyType energyType, float multiplier)
{
EnergyIntakeInfo info = intakeInfo.Find(x => x.type == energyType);
if (info != null)
{
info.multiplier = multiplier;
}
else
{
intakeInfo.Add(new EnergyIntakeInfo(energyType, multiplier));
}
}
public void dropBattery()
{
if (carrying == null)
{
return;
}
var spawn = GameObject.Instantiate(pickupPrefab, transform.position, Quaternion.identity);
spawn.setType(carrying);
carrying = null;
setState(State.stand);
// showSprite(normalSprite);
// renderer.sprite = normalSprite;
}
public IGraphicsObject CreateGraphic(EnergyType type, double value, double versorX,
double versorY, double versorZ, IColor color)
{
switch (type)
{
case EnergyType.UniaxialAnisotropy:
return(CreateDoubleArrow(value, versorX, versorY, versorZ, color));
case EnergyType.UZeeman:
return(CreateArrow(value, versorX, versorY, versorZ, color));
default: throw new NotImplementedException();
}
}
public Color GetEnergyColor(EnergyType _type)
{
if (m_energyInfos != null)
{
foreach (var info in m_energyInfos)
{
if (info.type == _type)
{
return(info.color);
}
}
}
return(Color.white);
}
public ActionResult GetPolygon(EnergyType type)
{
var polygons = db.Areas
.Where(x => x.Type == type)
.Select(x => new ViewArea
{
Id = x.Id,
Type = x.Type,
Rate = x.Rate,
Points = x.Polygon,
});
return(Json(polygons, JsonRequestBehavior.AllowGet));
}
public Building(String Name, PeerStatus status, EnergyType enType, float enProduced, float energyPeak, float price, string address, string adminName)
: base(Name)
{
_name = Name;
_enType = enType;
_enProduced = enProduced;
_enPeak = energyPeak;
_price = price;
_address = address;
_adminName = adminName;
_status = status;
_pwManager = new PowerManager(Name, status, new EnergyGenerator(enType, enProduced), energyPeak, price);
}
public void SetType( EnergyType newEnergyType )
{
energyType = newEnergyType;
if ( particleSystem ) {
switch ( energyType ) {
case EnergyType.Earth:
particleSystem.startColor = earthColor;
break;
case EnergyType.Fire:
particleSystem.startColor = fireColor;
break;
case EnergyType.Water:
particleSystem.startColor = waterColor;
break;
case EnergyType.Black:
particleSystem.startColor = blackColor;
break;
}
}
}
// Update is called once per frame
void Update()
{
if ( Input.GetButton( "suck" ) ) {
if ( curEnergy < maxEnergy ) {
Collider[] foundDudes = Physics.OverlapSphere( transform.position, pullRange );
foreach ( Collider foundDude in foundDudes ) {
// Check if any found dudes are Energy
EnergyUnit energy = foundDude.GetComponent<EnergyUnit>();
if ( energy && ( curEnergy == 0 || curEnergyType == energy.energyType ) && energy.energyType != EnergyType.Black ) {
// Found an energy unit with the same type of energy as me!
float distance = Vector3.Distance( transform.position, energy.transform.position );
float dot = Vector3.Dot( transform.forward, (energy.transform.position - transform.position).normalized );
if ( distance < absorbRange ) {
// Absorb the energy
curEnergy += 1;
curEnergyType = energy.energyType;
Destroy( energy.gameObject );
} else if ( dot > 0.94 ) {
// pull energy
energy.rigidbody.AddForce( ( transform.position - energy.transform.position ).normalized * absorbStrength / ( distance / pullRange ) );
}
}
}
}
} else if ( Input.GetButton( "blow" ) ) {
if ( curEnergy > 0 && Time.time > nextFire ) {
Rigidbody energy = Instantiate( energyUnit, transform.position, Quaternion.identity ) as Rigidbody;
energy.velocity = transform.forward * blowVelocity;
energy.GetComponent<EnergyUnit>().SetType( curEnergyType );
nextFire = Time.time + 1 / blowSpeed;
curEnergy -= 1;
}
}
}
public static string GetWeaponEnergyKey(EnergyType type) {
if(type == EnergyType.Unlimited || type == EnergyType.NumTypes)
return null;
return weaponEnergyPrefix + ((int)type);
}
private void Clear()
{
this.searchType = EnergyType.None;
this.SearchResults.Clear();
this.Query = string.Empty;
}
public List<RaisableObject> Search(string query, EnergyType type)
{
query = query.ToLower();
List<RaisableObject> result = new List<RaisableObject>();
switch (type)
{
case EnergyType.Activity:
var activityKeys = activityTranslations.Where(item =>
{
var lower = item.Value.ToLower();
return lower.StartsWith(query) || lower.Contains(query);
}).Select(item => item.Key);
using (var repo = new PhysicalActivityRepository())
{
result = repo.Search(activityKeys).Cast<RaisableObject>().ToList();
}
break;
case EnergyType.Food:
var foodKeys = this.foodTranslations.Where(item =>
{
var lower = item.Value.ToLower();
return lower.StartsWith(query) || lower.Contains(query);
}).Select(item => item.Key);
using (var repo = new FoodRepository())
{
result = repo.Search(foodKeys).Cast<RaisableObject>().ToList();
}
break;
}
return result;
}
private void Clear()
{
TotalEnergy = 0;
TodayItems.Clear();
energyType = EnergyType.None;
}
