public ActionResult Update(Sliders slider)
{
if (ModelState.IsValid)
{
db = new StorehouseDBContext();
if (Request.Files["sliderImage"].ContentLength > 0)
{
FileInfo sliderImageInfo = new FileInfo(Request.Files["sliderImage"].FileName);
string webRootPath = Server.MapPath("~");
string sliderImageFilename = string.Concat(ConfigurationManager.AppSettings["UploadFilePath"], "Sliders/", slider.Id.ToString(), sliderImageInfo.Extension);
Request.Files["sliderImage"].SaveAs(Server.MapPath(sliderImageFilename));
slider.SlideImage = sliderImageFilename;
}
if (Request.Files["sliderBackground"].ContentLength > 0)
{
FileInfo sliderBackgroundInfo = new FileInfo(Request.Files["sliderBackground"].FileName);
string webRootPath = Server.MapPath("~");
string sliderBackgroundFilename = string.Concat(ConfigurationManager.AppSettings["UploadFilePath"], "Sliders/", ConfigurationManager.AppSettings["SliderBackgroundPrefix"], slider.Sequence, sliderBackgroundInfo.Extension);
Request.Files["sliderBackground"].SaveAs(Server.MapPath(sliderBackgroundFilename));
slider.SlideBackground = sliderBackgroundFilename;
}
db.Entry(slider).State = EntityState.Modified;
db.SaveChanges();
}
return(RedirectToAction("Index", "Sliders"));
}
public static void DestroySingl()
{
if (array_means_sliders != null)
{
array_means_sliders = null;
}
}
public ActionResult CreateSlider(Sliders model, HttpPostedFileBase img)
{
if (ModelState.IsValid)
{
if (CheckContentImage.IsImage(img) && img != null)
{
string filename = Guid.NewGuid() + Path.GetExtension(img.FileName);
img.SaveAs(Server.MapPath("/img/") + filename);
model.ImageSlider = "/img/" + filename;
db.Sliderses.Add(model);
db.SaveChanges();
return(Redirect("/Admin/Home/Sliders"));
}
ModelState.AddModelError("ImageSlider", "لطفا تصویر خود را با فرمت مجاز ارسال فرمایید");
}
foreach (var VARIABLE in liStrings)
{
data_transition.Add(new SelectListItem()
{
Text = VARIABLE,
Value = VARIABLE
});
}
ViewBag.data_transition = new SelectList(data_transition, "Value", "Text");
ViewBag.data_slotamount = new SelectList(data_slotamount, "Value", "Text");
ViewBag.data_masterspeed = new SelectList(data_masterspeed, "Value", "Text");
ViewBag.data_Delay = new SelectList(data_Delay, "Value", "Text");
ViewBag.data_saveperformance = new SelectList(data_saveperformance, "Value", "Text");
ViewBag.Imagedatabgposition = new SelectList(Imagedatabgposition, "Value", "Text");
ViewBag.Imagedatabgfit = new SelectList(Imagedatabgfit, "Value", "Text");
return(View(model));
}
public async Task <IActionResult> Edit(int id, [Bind("id,Title1,Title2,Description,Image,IsDeleted")] Sliders sliders)
{
if (id != sliders.id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(sliders);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SlidersExists(sliders.id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(sliders));
}
protected void BtnYaziEkle_Click(object sender, EventArgs e)
{
string icerik = txtSliderYazi.Text;
SliderYazi Sy = new SliderYazi();
Sy.Icerik = icerik;
switch (DrpIcerikTur.SelectedValue)
{
case "0":
Sy.BuyukBaslik = true;
break;
case "1":
Sy.BuyukAltBaslik = true;
break;
case "2":
Sy.DegisenYazi = true;
break;
}
Sliders.SliderYaziEkle(Sy);
txtSliderYazi.Text = string.Empty;
GridViewBuyukBaslik.DataBind();
GridViewBuyukBaslikAlti.DataBind();
GridViewDegisenYazi.DataBind();
}
public async Task <IActionResult> Edit(int?id, Sliders sliders)
{
if (!ModelState.IsValid)
{
return(View(sliders));
}
Sliders slidersdb = await _context.Sliders.FindAsync(id);
if (sliders.Photo != null)
{
if (sliders.Photo.ContentType.Contains("image/"))
{
string path = _env.WebRootPath + @"\image\" + slidersdb.Image;
if (System.IO.File.Exists(path))
{
System.IO.File.Delete(path);
}
slidersdb.Image = await sliders.Photo.SaveFileAsync(_env.WebRootPath);
}
else
{
ModelState.AddModelError("Photo", "Selected image is not valid!");
return(View(sliders));
}
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Create(Sliders sliders)
{
if (!ModelState.IsValid)
{
return(View(sliders));
}
if (!sliders.Photo.ContentType.Contains("image/"))
{
ModelState.AddModelError("Photo", "Selected image is not valid!");
return(View(sliders));
}
if (sliders.Photo == null)
{
ModelState.AddModelError("Photo", "Please select any image!");
return(View(sliders));
}
sliders.Image = await sliders.Photo.SaveFileAsync(_env.WebRootPath);
await _context.Sliders.AddAsync(sliders);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
// GET: Sliders/Edit/5
public ActionResult SliderEdit(int?id)
{
//if (id == null)
//{
// return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
//}
//Sliders sliders = db.Sliders.Find(id);
Sliders sliders = db.Sliders.Where(x => x.ID == id).SingleOrDefault();
SliderVM model = new SliderVM()
{
ID = sliders.ID,
SliderSitePath = sliders.SliderSitePath,
Title = sliders.Title,
Summary = sliders.Summary,
Detail = sliders.Detail
};
if (sliders == null)
{
return(HttpNotFound());
}
return(View(model));
}
public ActionResult SliderCreate(/*[Bind(Include = "ID,SliderSitePath,Title,Summary,Detail")]*/ SliderVM model, HttpPostedFileBase SliderSitePath)
{
if (ModelState.IsValid)
{
Sliders sliders = new Sliders();
if (SliderSitePath != null)
{
WebImage img = new WebImage(SliderSitePath.InputStream);
FileInfo imginfo = new FileInfo(SliderSitePath.FileName);
string sliderimgname = Guid.NewGuid().ToString() + imginfo.Extension;
img.Resize(100, 100);
img.Save("~/Uploads/sliders/" + sliderimgname);
model.SliderSitePath = "/Uploads/sliders/" + sliderimgname;
}
sliders.SliderSitePath = model.SliderSitePath;
sliders.Title = model.Title;
sliders.Summary = model.Summary;
sliders.Detail = model.Detail;
db.Sliders.Add(sliders);
db.SaveChanges();
return(RedirectToAction("SliderList"));
}
return(View(model));
}
public void InsertForm()
{
string new_filename = string.Empty;
if (fuImage.PostedFile.ContentLength != 0)
{
string original_filename = Path.GetFileName(fuImage.PostedFile.FileName);
new_filename =
Guid.NewGuid().ToString() +
Path.GetExtension(original_filename);
string new_filepath = Server.MapPath("~/Uploads/Slider/" + new_filename);
fuImage.PostedFile.SaveAs(new_filepath);
ViewState["GImage"] = new_filename;
}
using (VaranegarEntities db = new VaranegarEntities())
{
Sliders p = new Sliders();
p.SliderTitle = txtTitle.Text;
p.Priority = Convert.ToInt32(txtPrio.Text);
p.BigText = txtBigText.Text;
p.IsActive = chbActiveSlider.Checked;
p.LinkAddress = txtLinkAddress.Text;
p.LinkText = txtLinkTitle.Text;
p.SliderImageUrl = new_filename;
p.SmallText = txtSmallText.Text;
p.IsDelete = false;
db.Sliders.Add(p);
db.SaveChanges();
}
}
public ActionResult EditeSlider(Sliders model, HttpPostedFileBase img)
{
if (ModelState.IsValid)
{
if (img != null && CheckContentImage.IsImage(img))
{
System.IO.File.Delete(Server.MapPath(model.ImageSlider));
string filename = Guid.NewGuid() + Path.GetExtension(img.FileName);
img.SaveAs(Server.MapPath("/img/") + filename);
model.ImageSlider = "/img/" + filename;
}
db.Entry(model).State = EntityState.Modified;
db.SaveChanges();
return(Redirect("/Admin/Home/Sliders"));
}
foreach (var VARIABLE in liStrings)
{
data_transition.Add(new SelectListItem()
{
Text = VARIABLE,
Value = VARIABLE
});
}
ViewBag.data_transition = new SelectList(data_transition, "Value", "Text", model.data_transition);
ViewBag.data_slotamount = new SelectList(data_slotamount, "Value", "Text", model.data_slotamount);
ViewBag.data_masterspeed = new SelectList(data_masterspeed, "Value", "Text", model.data_masterspeed);
ViewBag.data_Delay = new SelectList(data_Delay, "Value", "Text", model.data_Delay);
ViewBag.data_saveperformance = new SelectList(data_saveperformance, "Value", "Text", model.data_saveperformance);
ViewBag.Imagedatabgposition = new SelectList(Imagedatabgposition, "Value", "Text", model.Imagedatabgposition);
ViewBag.Imagedatabgfit = new SelectList(Imagedatabgfit, "Value", "Text", model.Imagedatabgfit);
return(View(model));
}
public static Menu Create(string name, Ability ability)
{
var menu = new Menu(name, name, textureName: name);
if (!ability.IsAbilityBehavior(AbilityBehavior.NoTarget) ||
(name == "item_pipe" || name == "item_buckler" || name == "omniknight_guardian_angel" ||
name == "item_crimson_guard"))
{
menu.AddItem(Togglers.UseOnAllies(name));
}
menu.AddItem(Sliders.MissingHpMin(name));
menu.AddItem(Sliders.HpPercentBelow(name));
if (name == "item_pipe" || name == "item_buckler" || name == "omniknight_guardian_angel" ||
name == "item_crimson_guard")
{
menu.AddItem(
new MenuItem(name + "minalliesaffect", "Minimum affected allies: ").SetValue(
new StringList(new[] { "1", "2", "3", "4" }, 1)));
}
menu.AddItem(
new MenuItem(name + "minenemiesaround", "Minimum of enemies near: ").SetValue(
new StringList(new[] { "1", "2", "3", "4", "5" })));
menu.AddItem(
new MenuItem(name + "usenearbool", "Use when near selected enemy: ").SetValue(true)
.SetTooltip("Use the ability only when affected target is near selected enemy"));
menu.AddItem(Togglers.UseNear(name));
return(menu);
}
protected void btnDelete_Click(object sender, EventArgs e)
{
try
{
int sliderId = Convert.ToInt32(hdnSliderId.Value);
Sliders Sliders = context.Slider.Where(m => m.Slider_Id == sliderId).FirstOrDefault();
context.Entry(Sliders).State = System.Data.Entity.EntityState.Deleted;
context.SaveChanges();
string filePath = Server.MapPath("~/" + Sliders.Slider_Photo);
FileInfo file = new FileInfo(filePath);
if (file.Exists)
{
file.Delete();
}
Response.Redirect("/administration/home/slider.aspx?id=3000&redirecturl=admin-slider-RachnaTeracotta");
}
catch (Exception ex)
{
pnlErrorMessage.Attributes.Remove("class");
pnlErrorMessage.Attributes["class"] = "alert alert-danger alert-dismissable";
pnlErrorMessage.Visible = true;
lblMessage.Text = ex.Message;
}
}
public static Menu Create(string name, Ability ability)
{
var menu = new Menu(name, name, textureName: name);
menu.AddItem(Togglers.UseOn(name));
menu.AddItem(Sliders.MinHealth(name));
if (name == "zuus_thundergods_wrath")
{
menu.AddItem(
new MenuItem(name + "minenemykill", "Minimum heroes to kill: ").SetValue(new Slider(1, 1, 5)));
}
menu.AddItem(
new MenuItem(name + "combo", "Use in combo: ").SetValue(true)
.SetTooltip("Allows the ability to be used along with other nukes in combo when killstealing"));
menu.AddItem(Sliders.MinManaCheck(name));
menu.AddItem(Sliders.MinManaCheck(name, true));
if (ability.IsAbilityBehavior(AbilityBehavior.AreaOfEffect, name) ||
ability.IsAbilityBehavior(AbilityBehavior.Point, name) || ability.IsSkillShot())
{
menu.AddItem(Togglers.OnDisableEnemy(name));
menu.AddItem(
new MenuItem(name + "minstraighttime", "Minimum enemy straight time (ms): ").SetValue(
new Slider(600, 0, 5000))
.SetTooltip(
"Enemy has to walk straight for this amount of ms in order for this ability to be used"));
}
return(menu);
}
/// <summary>
/// 修改信息
/// </summary>
/// <param name="sld"></param>
/// <returns></returns>
public bool Edit(Sliders sld)
{
StringBuilder sb = new StringBuilder();
sb.Append("update slider set title=@title,url=@url,link=@link,skip=@skip,userid=@userid,utime=@utime where id=@id");
return(dal.ExecBool(sb.ToString(), sld));
}
public static Menu Create(string name, Ability ability)
{
var menu = new Menu(name, name, textureName: name);
if (name == "rubick_spell_steal")
{
return(menu);
}
menu.AddItem(Togglers.OnSight(name));
var data = AbilityDatabase.Find(name);
var defaultValue = ability.AbilityType != AbilityType.Ultimate;
if (data != null)
{
if (data.TrueSight)
{
menu.AddItem(Togglers.OnInvisible(name, defaultValue));
}
if (data.IsPurge)
{
menu.AddItem(Togglers.OnPurgable(name, defaultValue));
}
if (data.WeakensEnemy)
{
menu.AddItem(Togglers.OnAttack(name, defaultValue));
}
}
menu.AddItem(Sliders.MinManaCheck(name));
menu.AddItem(Sliders.MinManaCheck(name, true));
return(menu);
}
public async Task <IActionResult> Create(Sliders slider)
{
if (!ModelState.IsValid)
{
return(View(slider));
}
if (_context.Sliders.Count() >= 5)
{
ModelState.AddModelError("Photos", "You can show only 5 slides");
return(View(slider));
}
if (!slider.Photo.PhotoValidate(ModelState))
{
return(View(slider));
}
string folder = Path.Combine("site", "img", "slider");
string fileName = await slider.Photo.SaveImage(_env.WebRootPath, folder);
slider.Image = fileName;
slider.IsDeleted = false;
await _context.Sliders.AddRangeAsync(slider);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Status(int?id)
{
if (id == null)
{
return(NotFound());
}
Sliders slider = await _context.Sliders.FindAsync(id);
if (slider == null)
{
return(NotFound());
}
if (_context.Sliders.Count(s => s.Activeted && !s.IsDeleted) < 2 && slider.Activeted)
{
return(Json("Image isnt' change status!"));
}
slider.Activeted = !slider.Activeted;
await _context.SaveChangesAsync();
return(Json(new
{
suc = true,
status = slider.Activeted
}));
}
public ActionResult Update(Sliders slider, HttpPostedFileBase file)
{
using (var unitOfWork = new UnitOfWork())
{
var temp = unitOfWork.Sliders.Find(x => x.SliderId == slider.SliderId);
if (file != null)
{
FileHelper filehelper = new FileHelper();
var mpath = Server.MapPath("~/Images/Product");
slider.SliderImageUrl = filehelper.SaveImage(file, mpath, "/Images/Slider");
slider.CreationDate = DateTime.Now;
temp.SliderTitle = slider.SliderTitle;
temp.SliderImageUrl = slider.SliderImageUrl;
temp.IsActive = slider.IsActive;
temp.CreationDate = slider.CreationDate;
}
unitOfWork.Sliders.Save();
return(RedirectToAction("Index", "Slider"));
}
}
private async void Slider_ValueChanged(object sender, RoutedPropertyChangedEventArgs <double> e)
{
if (isLoading)
{
return;
}
var slider = sender as Slider;
var textblock = TextBlocks[Sliders.IndexOf(slider)];
textblock.Text = slider.Value.ToString();
handAngles[(int)slider.Tag - 1] = (int)slider.Value;
var command = new PipeCommands.SetHandAngle {
HandAngles = handAngles
};
if (LeftHandRadioButton.IsChecked == true)
{
command.LeftEnable = true;
}
if (RightHandRadioButton.IsChecked == true)
{
command.RightEnable = true;
}
if (BothHandRadioButton.IsChecked == true)
{
command.LeftEnable = command.RightEnable = true;
}
await Globals.Client.SendCommandAsync(command);
CustomNameTextBox.Text = "カスタム";
}
// Assign slider to finger
private void FindSlider(Sliders sl)
{
if (obj.name.Contains("Thumb"))
{
nameShort = "T";
slider = sl.sliderThumb;
}
if (obj.name.Contains("Index"))
{
nameShort = "I";
slider = sl.sliderIndex;
}
if (obj.name.Contains("Middle"))
{
nameShort = "M";
slider = sl.sliderMiddle;
}
if (obj.name.Contains("Ring"))
{
nameShort = "R";
slider = sl.sliderRing;
}
if (obj.name.Contains("Pinky"))
{
nameShort = "P";
slider = sl.sliderPinky;
}
}
public static Menu Create(string name)
{
var menu = new Menu(name, name, textureName: name);
if (name != "antimage_mana_void" && name != "necrolyte_reapers_scythe" && name != "item_cyclone")
{
menu.AddItem(Togglers.OnSight(name));
menu.AddItem(Togglers.UnderTower(name));
menu.AddItem(Togglers.OnChannel(name));
menu.AddItem(Togglers.OnChainStun(name));
menu.AddItem(Togglers.OnCast(name));
}
else
{
menu.AddItem(Togglers.OnSight(name));
menu.AddItem(Togglers.UnderTower(name, false));
menu.AddItem(Togglers.OnChannel(name));
menu.AddItem(Togglers.OnChainStun(name, false));
menu.AddItem(Togglers.OnCast(name, false));
}
menu.AddItem(Sliders.MinManaCheck(name));
menu.AddItem(Sliders.MinManaCheck(name, true));
return(menu);
}
private void preMLBdown_addSliderHandler(object sender, MouseButtonEventArgs e)
{
Slider sourceSlider = e.Source as Slider;
if (sourceSlider != null && DrivingSlider == Sliders.nil)
{
switch (sourceSlider.Name)
{
case "sliderAlpha":
sliderAlpha.ValueChanged += AlphaThumbMove;
DrivingSlider = Sliders.A;
break;
case "sliderRed":
sliderRed.ValueChanged += RedThumbMove;
DrivingSlider = Sliders.R;
break;
case "sliderGreen":
sliderGreen.ValueChanged += GreenThumbMove;
DrivingSlider = Sliders.G;
break;
case "sliderBlue":
sliderBlue.ValueChanged += BlueThumbMove;
DrivingSlider = Sliders.B;
break;
case "sliderSpectrum":
sliderSpectrum.ValueChanged += HueThumbMove;
DrivingSlider = Sliders.H;
break;
}
}
}
private void removeSliderHandler()
{
switch (DrivingSlider)
{
case Sliders.A:
sliderAlpha.ValueChanged -= AlphaThumbMove;
break;
case Sliders.R:
sliderRed.ValueChanged -= RedThumbMove;
break;
case Sliders.G:
sliderGreen.ValueChanged -= GreenThumbMove;
break;
case Sliders.B:
sliderBlue.ValueChanged -= BlueThumbMove;
break;
case Sliders.H:
sliderSpectrum.ValueChanged -= HueThumbMove;
break;
}
DrivingSlider = Sliders.nil;
}
public async Task <IActionResult> Update(int?id, Sliders slider)
{
if (id == null)
{
return(NotFound());
}
Sliders sliderDb = await _context.Sliders.Where(s => !s.IsDeleted && s.Id == id).FirstOrDefaultAsync();
if (sliderDb == null)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(View(sliderDb));
}
if (slider.Photo != null)
{
if (!slider.Photo.PhotoValidate(ModelState))
{
return(View(sliderDb));
}
string folder = Path.Combine("site", "img", "slider");
string fileName = await slider.Photo.SaveImage(_env.WebRootPath, folder);
sliderDb.Image = fileName;
}
sliderDb.Title = slider.Title;
sliderDb.ShortDescription = slider.ShortDescription;
sliderDb.Activeted = slider.Activeted;
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
/// <summary>
/// 添加信息
/// </summary>
/// <param name="sld"></param>
/// <returns></returns>
public bool Add(Sliders sld)
{
StringBuilder sb = new StringBuilder();
sb.Append("insert into slider (title,url,link,skip,userid,utime,status) values(@title,@url,@link,@skip,@userid,@utime,@status)");
return(dal.ExecBool(sb.ToString(), sld));
}
public static Menu Create(string name)
{
var menu = new Menu(name, name, textureName: name);
menu.AddItem(Togglers.OnSight(name));
menu.AddItem(Togglers.OnAttack(name));
if (name == "item_armlet")
{
menu.AddItem(
new MenuItem(name + "belowhpslider", "Toggle when HP is below: ").SetValue(
new Slider(350, 100, 1000)));
menu.AddItem(
new MenuItem(name + "armletdelay", "Toggles delay: ").SetValue(new Slider(1300, 500, 2500)));
menu.AddItem(
new MenuItem(name + "alwaystoggle", "Toggle always: ").SetValue(false)
.SetTooltip("Toggle armlet always when HP goes below specified treshold"));
}
if (name == "item_satanic")
{
menu.AddItem(
new MenuItem(name + "missinghpslider", "Use when missing HP is higher then: ").SetValue(
new Slider(500, 100, 1000)));
menu.AddItem(new MenuItem(name + "orsign", " OR").SetFontStyle(FontStyle.Bold, Color.White));
menu.AddItem(
new MenuItem(name + "belowhpslider", "Use when HP is below: ").SetValue(new Slider(1000, 500, 5000)));
}
menu.AddItem(Sliders.MinManaCheck(name));
menu.AddItem(Sliders.MinManaCheck(name, true));
return(menu);
}
public void Delete(int sliderId)
{
Sliders slider = GetById(sliderId);
_sliderRepository.Delete(slider);
_unitOfWork.Complete();
}
public static Menu Create(string name)
{
var menu = new Menu(name, name, textureName: name);
if (name == "item_soul_ring")
{
menu.AddItem(
new MenuItem(name + "useBeforeCast", "Use when about to cast mana requiring ability").SetValue(true));
menu.AddItem(new MenuItem(name + "minHp", "Minimum HP to use: ").SetValue(new Slider(200, 0, 1000)))
.SetTooltip("If your HP is below specified value, ability will not be used");
return(menu);
}
if (!(name == "item_magic_wand" || name == "item_magic_stick"))
{
menu.AddItem(Togglers.UseOnAllies(name));
}
if (name == "item_arcane_boots")
{
menu.AddItem(Sliders.MissingManaMin(name));
menu.AddItem(Sliders.ManaPercentBelow(name));
}
else
{
menu.AddItem(Sliders.MissingHpMin(name));
menu.AddItem(Sliders.HpPercentBelow(name));
}
if (name == "item_mekansm" || name == "item_guardian_greaves" || name == "chen_hand_of_god")
{
menu.AddItem(
new MenuItem(name + "minalliesheal", "Minimum of healed allies: ").SetValue(
new StringList(new[] { "1", "2", "3", "4" }, 1)));
menu.AddItem(
new MenuItem(name + "waitrange", "Wait Range: ").SetValue(new Slider(2000, 1000, 6000))
.SetTooltip(
"If theres enabled ally hero in specified range, Ability# will wait for this hero to come in heal range"));
}
if (name == "item_arcane_boots")
{
menu.AddItem(
new MenuItem(name + "waitrange", "Wait Range: ").SetValue(new Slider(2000, 1000, 6000))
.SetTooltip(
"If theres enabled ally hero in specified range, Ability# will wait for this hero to come in heal range"));
}
else if (name != "item_urn_of_shadows")
{
menu.AddItem(
new MenuItem(name + "minenemiesaround", "Minimum of enemies near: ").SetValue(
new StringList(new[] { "1", "2", "3", "4", "5" })));
menu.AddItem(
new MenuItem(name + "usenearbool", "Use when near selected enemy: ").SetValue(true)
.SetTooltip("Use the ability only when affected target is near selected enemy"));
menu.AddItem(Togglers.UseNear(name));
}
return(menu);
}
public JsonResult UpdateActive(int?id)
{
var result = false;
if (id != null)
{
Sliders xdb = db.Sliders.FirstOrDefault(w => w.Id == id);
if (xdb.isActive == false)
{
xdb.isActive = true;
}
else
{
xdb.isActive = false;
}
db.Entry(xdb).State = EntityState.Modified;
db.SaveChanges();
result = true;
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
/// <summary>Returns the slider index from a value in the slider enumeration</summary>
/// <param name="slider">Slider enumeration values whose index will be returned</param>
/// <returns>The index of the specified slider enumeration value</returns>
private static int indexFromSlider(Sliders slider)
{
switch (slider)
{
case Sliders.Slider1:
{
return 0;
}
case Sliders.Slider2:
{
return 1;
}
case Sliders.Velocity1:
{
return 2;
}
case Sliders.Velocity2:
{
return 3;
}
case Sliders.Acceleration1:
{
return 4;
}
case Sliders.Acceleration2:
{
return 5;
}
case Sliders.Force1:
{
return 6;
}
case Sliders.Force2:
{
return 7;
}
default:
{
return -1;
}
}
}
/// <summary>Creates a slider reader for the specified object</summary>
/// <param name="joystick">Joystick providing the control object</param>
/// <param name="slider">Slider a reader will be created for</param>
/// <param name="control">Control description for the axis</param>
/// <returns>A new slider reader for the specified axis</returns>
private static ISliderReader createSliderReader(
Joystick joystick, Sliders slider, DeviceObjectInstance control
)
{
int id = (int) control.ObjectType;
ObjectProperties properties = joystick.GetObjectPropertiesById(id);
int min = properties.LowerRange;
int max = properties.UpperRange;
switch (slider)
{
case Sliders.Slider1:
{
return new SliderReader(0, min, max);
}
case Sliders.Slider2:
{
return new SliderReader(1, min, max);
}
case Sliders.Velocity1:
{
return new VelocitySliderReader(0, min, max);
}
case Sliders.Velocity2:
{
return new VelocitySliderReader(1, min, max);
}
case Sliders.Acceleration1:
{
return new AccelerationSliderReader(0, min, max);
}
case Sliders.Acceleration2:
{
return new AccelerationSliderReader(1, min, max);
}
case Sliders.Force1:
{
return new ForceSliderReader(0, min, max);
}
case Sliders.Force2:
{
return new ForceSliderReader(1, min, max);
}
default:
{
return null;
}
}
}
/// <summary>Initializes a new extended game pas state to the provided values</summary>
/// <param name="availableAxes">Bit mask of the axes made available in the state</param>
/// <param name="axes">
/// Values of all 24 axes in the order they appear in the ExtendedAxes enumeration
/// </param>
/// <param name="availableSliders">Bit mask of the slider provided by the state</param>
/// <param name="sliders">
/// Values of all 8 sliders in the order they appear in the ExtendedSliders enumeration
/// </param>
/// <param name="buttonCount">Number of buttons provided by the state</param>
/// <param name="buttons">State of all 128 buttons in the state</param>
/// <param name="povCount">Number of Point-of-View controllers in the state</param>
/// <param name="povs">State of all 4 Point-of-View controllers</param>
public GamePadState(
Axes availableAxes, float[ /*24*/] axes,
Sliders availableSliders, float[ /*8*/] sliders,
int buttonCount, bool[ /*128*/] buttons,
int povCount, int[ /*4*/] povs
)
{
// Take over all axes
this.AvailableAxes = availableAxes;
this.X = axes[0];
this.Y = axes[1];
this.Z = axes[2];
this.VelocityX = axes[3];
this.VelocityY = axes[4];
this.VelocityZ = axes[5];
this.AccelerationX = axes[6];
this.AccelerationY = axes[7];
this.AccelerationZ = axes[8];
this.ForceX = axes[9];
this.ForceY = axes[10];
this.ForceZ = axes[11];
this.RotationX = axes[12];
this.RotationY = axes[13];
this.RotationZ = axes[14];
this.AngularVelocityX = axes[15];
this.AngularVelocityY = axes[16];
this.AngularVelocityZ = axes[17];
this.AngularAccelerationX = axes[18];
this.AngularAccelerationY = axes[19];
this.AngularAccelerationZ = axes[20];
this.TorqueX = axes[21];
this.TorqueY = axes[22];
this.TorqueZ = axes[23];
// Take over all sliders
this.AvailableSliders = availableSliders;
this.Slider1 = sliders[0];
this.Slider2 = sliders[1];
this.VelocitySlider1 = sliders[2];
this.VelocitySlider2 = sliders[3];
this.AccelerationSlider1 = sliders[4];
this.AccelerationSlider2 = sliders[5];
this.ForceSlider1 = sliders[6];
this.ForceSlider2 = sliders[7];
// Take over all buttons
this.ButtonCount = buttonCount;
this.buttonState1 = 0;
for (int index = 0; index < Math.Min(64, buttonCount); ++index)
{
if (buttons[index])
{
this.buttonState1 |= (1UL << index);
}
}
this.buttonState2 = 0;
for (int index = 0; index < (buttonCount - 64); ++index)
{
if (buttons[index + 64])
{
this.buttonState2 |= (1UL << index);
}
}
// Take over all PoV controllers
this.PovCount = povCount;
this.Pov1 = povs[0];
this.Pov2 = povs[1];
this.Pov3 = povs[2];
this.Pov4 = povs[3];
}
/// <summary>Retrieves the state of the specified slider</summary>
/// <param name="slider">Slider whose state will be retrieved</param>
/// <returns>The state of the specified slider</returns>
public float GetSlider(Sliders slider)
{
switch (slider)
{
case Sliders.Slider1:
{
return this.Slider1;
}
case Sliders.Slider2:
{
return this.Slider2;
}
case Sliders.Velocity1:
{
return this.VelocitySlider1;
}
case Sliders.Velocity2:
{
return this.VelocitySlider2;
}
case Sliders.Acceleration1:
{
return this.AccelerationSlider1;
}
case Sliders.Acceleration2:
{
return this.AccelerationSlider2;
}
case Sliders.Force1:
{
return this.ForceSlider1;
}
case Sliders.Force2:
{
return this.ForceSlider2;
}
default:
{
throw new ArgumentOutOfRangeException("slider", "Invalid slider");
}
}
}
