static string GetState(UpdateState mu) {
if (string.IsNullOrWhiteSpace(mu.CurrentRevision))
return "New";
if (mu.IsEqual())
return "Diagnose";
return mu.IsNewer() ? "Upgrade" : "Downgrade";
}
private void OnMouseEvent(UIMouseEventType type, UpdateState state)
{
switch (type)
{
case UIMouseEventType.MouseOver:
//m_isOver = true;
break;
case UIMouseEventType.MouseOut:
//m_isOver = false;
break;
case UIMouseEventType.MouseDown:
m_isDown = true;
break;
case UIMouseEventType.MouseUp:
if (m_isDown)
{
if (OnButtonClick != null)
{
OnButtonClick(this);
//GameFacade.SoundManager.PlayUISound(1);
}
}
m_isDown = false;
break;
}
}
public void MouseUp(UpdateState state)
{
HITVM.Get().PlaySoundEvent(UISounds.BuildDragToolUp);
vm.Context.Architecture.RunCommands(Commands);
Commands.Clear();
Drawing = false;
}
public DialogResult ShowDialog(UpdateState state, string version="")
{
btn_yes.Text = "Yes";
btn_no.Text = "No";
string title="";
string desc="";
switch(state)
{
case UpdateState.OffsetsMissing:
pic_image.Image = Properties.Resources.file_missing;
btn_no.Text = "Exit program";
title="Offsets missing!";
desc= String.Format("{0} could not be found. Do you want to download the latest offsets?", settings.OffSetXML);
break;
case UpdateState.UpgradeTool:
title="Program update available!";
desc = String.Format("Dungeon Teller v{0} is available. Do you want to start the updater?", version);
break;
case UpdateState.UpdateOffsets:
title="Offset update available!";
desc = String.Format("Your offsets version: {0}\nLatest offsets version: {1}\nDo you want to update them now?", settings.WowVersion, version);
break;
}
lbl_title.Text = title;
lbl_desc.Text = desc;
return this.ShowDialog();
}
public void requestStateChange(string name)
{
if(this.InvokeRequired) {
UpdateState d = new UpdateState(requestStateChange);
this.Invoke(d, new object[]{name});
} else {
sHandler.activateState(name);
}
}
UpdateFrequency IUpdate.Update(UpdateState state)
{
if (disposed)
return UpdateFrequency.Terminate;
Update(state, state.PlayerInput[PlayerIndex].InputState);
return UpdateFrequency.FullUpdate60hz;
}
public void Update(UpdateState state)
{
DateTime now = DateTime.Now;
if (_lastCacheClean + _cleanInterval >= now)
return;
_landCache.Clean();
_lastCacheClean = now;
}
public void MouseDown(UpdateState state)
{
if (!Drawing)
{
HITVM.Get().PlaySoundEvent(UISounds.BuildDragToolDown);
Drawing = true;
var tilePos = World.State.WorldSpace.GetTileAtPosWithScroll(new Vector2(state.MouseState.X, state.MouseState.Y));
StartPosition = new Point((int)Math.Round(tilePos.X), (int)Math.Round(tilePos.Y));
}
}
public virtual void Update(UpdateState state)
{
MaterialManager.RefreshLights();
PhysicsSpace.Update();
foreach (var gameObject in beingRemoved)
{
drawToScreen.Remove(gameObject);
}
}
private void HolderPutDown(UIObjectSelection holding, UpdateState state)
{
if (OldSelection != -1)
{
if (!holding.IsBought && (state.KeyboardState.IsKeyDown(Keys.LeftShift) || state.KeyboardState.IsKeyDown(Keys.RightShift)))
{
//place another
var prevDir = holding.Dir;
Catalog_OnSelectionChange(OldSelection);
if (Holder.Holding != null)
{
Holder.Holding.Dir = prevDir;
}
}
else
{
Catalog.SetActive(OldSelection, false);
OldSelection = -1;
}
}
QueryPanel.Active = false;
}
private static TableGameInfo ParseDesktopTableRow(ISearchContext gameRow)
{
Console.WriteLine("Parsing desktop game row...");
bool included = gameRow.FindElement(By.ClassName(SiteConstants.RowIncludedCheckboxClass)).Selected;
string steamName = gameRow.FindElement(By.ClassName(SiteConstants.RowSteamNameSpanClass)).Text;
bool verifiedFinite = !gameRow.FindElement(By.ClassName(SiteConstants.RowVerifyGameAnchorId)).Displayed;
double currentPlayTime = GetPlaytime(gameRow.FindElement(By.ClassName(SiteConstants.RowSteamPlaytimeCellClass)).Text);
double mainPlaytime = GetPlaytime(gameRow.FindElement(By.ClassName(SiteConstants.RowMainPlaytimeCellClass)).Text);
double extrasPlaytime = GetPlaytime(gameRow.FindElement(By.ClassName(SiteConstants.RowExtrasPlaytimeCellClass)).Text);
double completionistPlaytime = GetPlaytime(gameRow.FindElement(By.ClassName(SiteConstants.RowCompletionistPlaytimeCellClass)).Text);
string hltbName = gameRow.FindElement(By.ClassName(SiteConstants.RowHltbNameAnchorClass)).Text;
bool missingCorrelation = gameRow.FindElement(By.ClassName(SiteConstants.RowMissingCorrelationSpanClass)).Displayed;
bool verifiedCorrelation = !gameRow.FindElement(By.ClassName(SiteConstants.RowWrongGameAnchorClass)).Displayed;
UpdateState updateState = gameRow.FindElement(By.ClassName(SiteConstants.RowCorrelationUpdatingSpanClass)).Displayed
? UpdateState.InProgress
: (gameRow.FindElement(By.ClassName(SiteConstants.RowCorrelationUpdateSubmittedClass)).Displayed
? UpdateState.Submitted
: (gameRow.FindElement(By.ClassName(SiteConstants.RowCorrelationUpdateFailedClass)).Displayed ? UpdateState.Failure : UpdateState.None));
return(new
TableGameInfo(included, steamName, verifiedFinite, currentPlayTime, mainPlaytime, extrasPlaytime, completionistPlaytime, missingCorrelation, hltbName, verifiedCorrelation, updateState));
}
private void HolderPutDown(UIObjectSelection holding, UpdateState state)
{
if (OldSelection != -1)
{
if (!holding.IsBought && holding.InventoryPID == 0 && (state.ShiftDown))
{
//place another
var prevDir = holding.Dir;
Catalog_OnSelectionChange(OldSelection);
if (Holder.Holding != null)
{
Holder.Holding.Dir = prevDir;
}
}
else
{
Catalog.SetActive(OldSelection, false);
OldSelection = -1;
}
}
QueryPanel.Active = false;
}
private void TouchStub(UpdateState state)
{
var test = TouchPanel.EnableMouseTouchPoint;
TouchCollection touches = TouchPanel.GetState();
if (touches.Count > 0)
{
if (touchedFrames < TOUCH_ACCEPT_TIME)
{
touchedFrames++;
}
else
{
//right click, take center
Vector2 avg = new Vector2();
for (int i = 0; i < touches.Count; i++)
{
avg += touches[i].Position;
}
avg /= touches.Count;
state.MouseState = new MouseState(
(int)avg.X, (int)avg.Y, state.MouseState.ScrollWheelValue,
(touches.Count > 1) ? ButtonState.Released : ButtonState.Pressed,
(touches.Count > 1) ? ButtonState.Pressed : ButtonState.Released,
ButtonState.Released,
ButtonState.Released,
ButtonState.Released
);
state.TouchMode = true;
}
}
else
{
touchedFrames = 0;
state.TouchMode = false;
}
}
private int GetRowUnderMouse(UpdateState update)
{
var mouse = this.GetMousePosition(update.MouseState);
var estRow = (int)Math.Floor(mouse.Y / RowHeight);
if (estRow >= 0 && estRow < VisibleRows)
{
estRow += VerticalScrollPosition;
if (estRow < m_Items.Count)
{
/** Is this row enabled? **/
var row = Items[estRow];
if (row.Disabled)
{
return(-1);
}
return(estRow);
}
}
return(-1);
}
public override void Update(UpdateState state)
{
base.Update(state);
var perm = ((VMTSOAvatarState)Avatar.TSOState).Permissions;
if (perm != LastPermissions)
{
UpdateAvatarState(perm);
}
var rmb = state.MouseState.RightButton == ButtonState.Pressed;
if (rmb && !RMB) //clicked
{
RMB = rmb;
if (Hovered)
{
CenterPerson(this);
}
}
RMB = rmb;
}
void SetupNode()
{
for (int i = 0; i < nodes.Count; i++)
{
UpdateState state = nodes[i].GetComponent <UpdateState>();
if (i == 0)
{
state.backNode = nodes[nodes.Count - 1];
state.nextNode = nodes[i + 1];
}
else if (i == nodes.Count - 1)
{
state.nextNode = nodes[0];
state.backNode = nodes[i - 1];
}
else
{
state.backNode = nodes[i - 1];
state.nextNode = nodes[i + 1];
}
}
}
public override void Update(UpdateState state)
{
if (Mode == 1)
{
if (Active)
{
Visible = true;
if (Opacity < 1f)
{
Opacity += 1f / 20f;
}
else
{
Opacity = 1;
}
}
else
{
if (Opacity > 0f)
{
Opacity -= 1f / 20f;
}
else
{
Visible = false;
Opacity = 0f;
}
}
}
else
{
Opacity = 1;
if (Active)
{
Visible = true;
}
}
base.Update(state);
}
public override void Update(UpdateState state)
{
if (!Updating)
{
if (Children.Count == 1)
{
if (CanUpdate)
{
BeginUpdate();
}
else
{
GameFacade.Game.Exit();
}
}
else if (state.CtrlDown && state.ShiftDown && state.NewKeys.Contains(Microsoft.Xna.Framework.Input.Keys.C))
{
FSOFacade.Controller.StartLoading();
}
}
base.Update(state);
}
public void MouseEvents(UIMouseEventType type, UpdateState state)
{
switch (type)
{
case UIMouseEventType.MouseDown:
MouseDownID = state.CurrentMouseID;
MouseDownTime = 0;
MouseDownAt = state.MouseState.Position;
InScroll = false;
ScrollVelocity = 0;
break;
case UIMouseEventType.MouseUp:
if (!InScroll)
{
Select(GlobalPoint(MouseDownAt.ToVector2()).ToPoint());
}
else
{
//calculate scroll velocity
if (ScrollVelocityHistory.Count > 1)
{
int total = 0;
ScrollVelocity = 0f;
for (int i = 1; i < ScrollVelocityHistory.Count; i++)
{
total++;
ScrollVelocity += ScrollVelocityHistory[i];
}
ScrollVelocity /= total;
}
ScrollVelocityHistory.Clear();
}
InScroll = false;
MouseDownID = -1;
break;
}
}
public IActionResult Save(NoteViewModel note)
{
if (ModelState.IsValid)
{
if (IfTitleExists(note))
{
ModelState.AddModelError("Title", "Title already exists");
return(View("Index", note));
}
if (note.Id == -1)
{
_notesDbRepository.Add(note);
}
else
{
UpdateState updateResult = _notesDbRepository.Update(note);
if (updateResult == UpdateState.Deleted)
{
ModelState.AddModelError("Title",
"Update not available. The note was deleted by another user.");
return(View("Index", note));
}
if (updateResult == UpdateState.Changed)
{
ModelState.Clear();
ModelState.AddModelError("Title",
"Update not available. The note was edited by another user "
+ "after you got the original value.");
return(View("Index", note));
}
}
return(Cancel());
}
return(View("Index", note));
}
private void MouseHandler(UIMouseEventType type, UpdateState state)
{
switch (type)
{
case UIMouseEventType.MouseOver:
OnHoveredLevel?.Invoke(Level);
break;
case UIMouseEventType.MouseOut:
OnHoveredLevel?.Invoke(-1);
break;
case UIMouseEventType.MouseDown:
Highlight = -0.15f;
break;
case UIMouseEventType.MouseUp:
SetHighlight(false);
OnClickedLevel?.Invoke(Level);
break;
}
}
/// <summary>
/// ImtStateMachine のインスタンスを初期化します
/// </summary>
/// <param name="context">このステートマシンが持つコンテキスト</param>
/// <exception cref="ArgumentNullException">context が null です</exception>
public ImtStateMachine(TContext context)
{
// 渡されたコンテキストがnullなら
if (context == null)
{
// nullは許されない
throw new ArgumentNullException(nameof(context));
}
// メンバの初期化をする
Context = context;
stateList = new List <State>();
stateStack = new Stack <State>();
updateState = UpdateState.Idle;
AllowRetransition = false;
UnhandledExceptionMode = ImtStateMachineUnhandledExceptionMode.ThrowException;
// この時点で任意ステートのインスタンスを作ってしまう
GetOrCreateState <AnyState>();
}
public override void Update(UpdateState state)
{
base.Update(state);
var pressedKeys = state.KeyboardState.GetPressedKeys();
//not sure if ts1 allowed you to use right ctrl or right shift but i dont discriminate
if ((pressedKeys.Contains(Keys.LeftControl) || pressedKeys.Contains(Keys.RightControl)) &&
(pressedKeys.Contains(Keys.LeftShift) || pressedKeys.Contains(Keys.RightShift)) &&
state.NewKeys.Contains(Keys.C)) //prevent change over multiple frames
{
Visible = !Visible;
}
baseTextbox.Visible = Visible;
if (Visible)
{
if (state.NewKeys.Contains(Keys.Enter))
{
commandEntered(baseTextbox.CurrentText, out bool shouldHide);
Visible = !shouldHide;
}
}
}
public override void Update(UpdateState state)
{
if (Active)
{
Visible = true;
if (Opacity < 1f)
{
Opacity += 1f / 20f;
}
else
{
Opacity = 1;
}
if (ActiveEntity != null && LastSalePrice != ActiveEntity.MultitileGroup.SalePrice && ActiveEntity.Thread != null)
{
var lastTab = Tab;
SetInfo(ActiveEntity.Thread.Context.VM, ActiveEntity, true);
Tab = lastTab;
}
}
else
{
if (Opacity > 0f)
{
Opacity -= 1f / 20f;
}
else
{
Visible = false;
Opacity = 0f;
}
}
base.Update(state);
if (Visible && Thumb3D != null)
{
Invalidate();
}
}
public override void Update(UpdateState state)
{
base.Update(state);
lock (AnimationRequests)
{
while (TargetTile != null && AnimationRequests.Count > 0)
{
var anim = AnimationRequests.Dequeue();
var animation = FSO.Content.Content.Get().AvatarAnimations.Get(anim + ".anim");
if (animation != null)
{
var astate = new VMAnimationState(animation, false);
astate.Loop = true;
((VMAvatar)TargetTile).Animations.Clear();
((VMAvatar)TargetTile).Animations.Add(astate);
}
}
}
state.SharedData["ExternalDraw"] = true;
}
public (JsonResult result, bool Succeeded) UpdateState(UpdateState state)
{
try
{
StateEntity states = _context.StateEntitys.FirstOrDefault(p => p.StateID == state.StateID);
_context.Entry(states).CurrentValues.SetValues(state);
if (_context.SaveChanges() == 1)
{
return(new JsonResult("State updated successfully."), true);
}
else
{
return(new JsonResult("Enter the correct values."), false);
}
}
catch (Exception ex)
{
return(new JsonResult("Some server error occured. Please try again!!"), false);
}
}
private void OnMouseEvent(UIMouseEventType type, UpdateState update)
{
switch (type)
{
case UIMouseEventType.MouseDown:
if (m_DoubleClickTime > 0)
{
if (OnDoubleClick != null)
{
OnDoubleClick(this);
}
m_DoubleClickTime = 0;
}
else
{
m_DoubleClickTime = 20;
}
break;
case UIMouseEventType.MouseOver:
m_MouseOver = true;
break;
case UIMouseEventType.MouseOut:
m_MouseOver = false;
break;
case UIMouseEventType.MouseUp:
/** Click **/
var row = GetRowUnderMouse(update);
if (row != -1)
{
/** Cant deselect once selected **/
InternalSelect(row);
}
break;
}
}
private void SendUpdateStatePacket(UpdateState state, IPAddress remote, int port, string mac)
{
//发送自己的信息，让发送方也更新
UdpPacket packetRsp = new UdpPacket();
packetRsp.Address = remote;
packetRsp.Port = port;
packetRsp.ToMAC = mac;
packetRsp.FromMAC = this.MAC;
packetRsp.Command = UdpPacket.CMD_STATE;
UdpPacketStateExtend entryExtend = new UdpPacketStateExtend();
if ((state & LanIM.UpdateState.Photo) != 0)
{
packetRsp.Command |= UdpPacket.CMD_OPTION_STATE_PROFILE_PHOTO;
entryExtend.ProfilePhoto = ProfilePhotoPool.GetPhoto(this.ID, false);
}
if ((state & LanIM.UpdateState.NickName) != 0)
{
packetRsp.Command |= UdpPacket.CMD_OPTION_STATE_NICKNAME;
entryExtend.NickName = this.NickName;
}
if ((state & LanIM.UpdateState.PublicKey) != 0)
{
packetRsp.Command |= UdpPacket.CMD_OPTION_STATE_PUBKEY;
entryExtend.PublicKey = _client.SecurityKeys.Public;
}
if ((state & LanIM.UpdateState.Status) != 0)
{
packetRsp.Command |= UdpPacket.CMD_OPTION_STATE_STATUS;
entryExtend.Status = this.Status;
}
packetRsp.Extend = entryExtend;
_client.Send(packetRsp);
}
/**
* Interaction Functionality
*/
public void OnMouseEvent(UIMouseEventType evt, UpdateState state)
{
if (m_IsReadOnly)
{
return;
}
switch (evt)
{
case UIMouseEventType.MouseDown:
/**
* Hit test, work out where selection should begin
*/
var position = this.GetMousePosition(state.MouseState);
var index = this.HitTestText(position);
Control_SetSelectionStart(
Control_GetSelectableIndex(index, -1)
);
SelectionEnd = -1;
m_IsDraggingSelection = true;
state.InputManager.SetFocus(this);
break;
case UIMouseEventType.MouseOver:
GameFacade.Cursor.SetCursor(CursorType.IBeam);
break;
case UIMouseEventType.MouseOut:
GameFacade.Cursor.SetCursor(CursorType.Normal);
break;
case UIMouseEventType.MouseUp:
m_IsDraggingSelection = false;
break;
}
}
private void MouseEvents(UIMouseEventType evt, UpdateState state)
{
switch (evt)
{
case UIMouseEventType.MouseOver:
Master.HoverPrim = this;
break;
case UIMouseEventType.MouseOut:
if (Master.HoverPrim == this)
{
Master.HoverPrim = null;
}
break;
case UIMouseEventType.MouseDown:
Master.Select(this);
if (DoubleClickTime > 0 && Type == PrimBoxType.Primitive && Descriptor is SubroutineDescriptor)
{
var subD = (SubroutineDescriptor)Descriptor;
Client.Diagnostics.IDEHook.IDE.IDEOpenBHAV(Master.Scope.GetBHAV(subD.PrimID), Master.Scope.Object);
}
DoubleClickTime = 25;
m_doDrag = true;
var position = this.GetMousePosition(state.MouseState);
m_dragOffsetX = position.X;
m_dragOffsetY = position.Y;
break;
case UIMouseEventType.MouseUp:
m_doDrag = false; //should probably just release when mouse is up in any case.
break;
default:
break;
}
}
public override void Update(UpdateState state)
{
base.Update(state);
var i = 0;
foreach (var item in Items)
{
foreach (var col in item.Columns)
{
if (col is UIContainer)
{
var container = ((UIContainer)col);
container.Visible = i >= ScrollOffset && i < ScrollOffset + NumVisibleRows;
if (container.Visible)
{
container.Parent = this.Parent;
container.InvalidateMatrix();
container.Update(state);
container.Parent = null;
}
else
{
container.Update(state);
}
}
}
i++;
}
if (m_MouseOver)
{
var overRow = GetRowUnderMouse(state);
m_HoverRow = overRow;
}
else
{
m_HoverRow = -1;
}
}
public void Update(UpdateState state)
{
/**
* Handle the mouse events from the previous frame
* Its important to do this before the update calls because
* a lot of mouse events will make changes to the UI. If they do
* we want the Matrix's to be recalculated before the draw
* method and that is done in the update method.
*/
inputManager.HandleMouseEvents(state);
state.MouseEvents.Clear();
state.InputManager = inputManager;
Content.Content.Get().Changes.RunResModifications();
mainUI.Update(state);
lock (m_ExtContainers)
{
var extCopy = new List <UIExternalContainer>(m_ExtContainers);
foreach (var ext in extCopy)
{
lock (ext)
{
ext.Update(state);
}
}
}
/** Process external update handlers **/
foreach (var item in m_UIProcess)
{
item.Update(state);
}
Tooltip = state.UIState.Tooltip;
TooltipProperties = state.UIState.TooltipProperties;
}
private void OnMouseEvent(UIMouseEventType type, UpdateState update)
{
switch (type)
{
case UIMouseEventType.MouseOver:
m_MouseOver = true;
break;
case UIMouseEventType.MouseOut:
m_MouseOver = false;
break;
case UIMouseEventType.MouseUp:
/** Click **/
var row = GetRowUnderMouse(update);
if (row != -1)
{
/** Cant deselect once selected **/
InternalSelect(row);
}
break;
}
}
private void OnMouse(UIMouseEventType type, UpdateState state)
{
if (type == UIMouseEventType.MouseOver)
{
if (isDown) { return; }
color = Color.Red;
}
else if (type == UIMouseEventType.MouseOut)
{
if (isDown) { return; }
color = Color.White;
}
else if (type == UIMouseEventType.MouseDown)
{
color = Color.Blue;
isDown = true;
}
else if (type == UIMouseEventType.MouseUp)
{
isDown = false;
color = Color.Green;
}
}
public void Update(UpdateState state)
{
m_FPS = (float)(1 / state.Time.ElapsedGameTime.TotalSeconds);
/**
* Handle the mouse events from the previous frame
* Its important to do this before the update calls because
* a lot of mouse events will make changes to the UI. If they do
* we want the Matrix's to be recalculated before the draw
* method and that is done in the update method.
*/
inputManager.HandleMouseEvents(state);
state.MouseEvents.Clear();
state.InputManager = inputManager;
mainUI.Update(state);
/** Process external update handlers **/
foreach (var item in m_UIProcess)
{
item.Update(state);
}
}
private void _ShowPopup(string title, string message, UpdateState state)
{
if (AppSettings.Instance.DisableNotifications)
{
return;
}
if (AppSettings.Instance.UseMetroStyle)
{
var popup = new PopupView();
popup.DataContext = new PopupViewModel(title, message, state, popup.Close, OpenWindowsUpdateControlPanel);
popup.Show();
if (mSettingsView != null)
{
mSettingsView.Focus();
}
}
else
{
mTrayIcon.ShowBallonTip(title, message, state);
}
}
public void MouseUp(UpdateState state)
{
if (Drawing)
{
var cmds = new List <VMArchitectureCommand>(Commands.Values);
if (cmds.Count > 0 && (Parent.ActiveEntity == null || vm.Context.Architecture.LastTestCost <= Parent.ActiveEntity.TSOState.Budget.Value))
{
vm.SendCommand(new VMNetArchitectureCmd
{
Commands = new List <VMArchitectureCommand>(cmds)
});
HITVM.Get().PlaySoundEvent(UISounds.BuildDragToolPlace);
}
else
{
HITVM.Get().PlaySoundEvent(UISounds.BuildDragToolUp);
}
}
Drawing = false;
Commands.Clear();
}
/// <summary>
/// Informs the drawing context of the visual node that is about to be rendered.
/// </summary>
/// <param name="node">The visual node.</param>
/// <returns>
/// An object which when disposed will commit the changes to visual node.
/// </returns>
public UpdateState BeginUpdate(VisualNode node)
{
Contract.Requires<ArgumentNullException>(node != null);
if (_node != null)
{
if (_childIndex < _node.Children.Count)
{
_node.ReplaceChild(_childIndex, node);
}
else
{
_node.AddChild(node);
}
++_childIndex;
}
var state = new UpdateState(this, _node, _childIndex, _drawOperationindex);
_node = node;
_childIndex = _drawOperationindex = 0;
return state;
}
public override void Update(UpdateState state)
{
base.Update(state);
if (LastVal != SearchBox.CurrentText)
{
LastVal = SearchBox.CurrentText;
if (Filter != null)
{
Filter = null;
RedrawRels();
}
}
if (LastName != TargetIcon.Tooltip)
{
LastName = TargetIcon.Tooltip;
Caption = GameFacade.Strings.GetString("f106", "11", new string[] { LastName });
}
Invalidate(); //for now invalidate friendship web every frame, because its listbox is pretty complicated.
//buttonseat_transparent = 0x19700000002,
}
/// <summary>
/// Инициализирует экземпляр класса.
/// </summary>
/// <param name="rootDirectory">Корневая папка, в которой происходят обновления</param>
/// <param name="serverPidFile">Адрес pid файла на сервере</param>
/// <param name="localPidFile">Путь к локальному Pid файлу</param>
/// <param name="serverPatchListFile">Адрес файла c описанием файлов для обновления на сервере</param>
/// <param name="serverFilesRoot">Корневая папка на сервере, в которой лежат файлы для обновления</param>
public WowUpdater(string rootDirectory, string serverPidFile, string localPidFile, string serverPatchListFile, string serverFilesRoot)
{
if (!Directory.Exists(rootDirectory))
{
throw new DirectoryNotFoundException("rootDirectory");
}
_rootDirectory = rootDirectory;
_serverPidFile = serverPidFile;
_localPidFile = localPidFile;
_serverPatchListFile = serverPatchListFile;
_serverFilesRoot = serverFilesRoot;
_syncContext = SynchronizationContext.Current ?? new SynchronizationContext();
_webClientFactory = new WebClientFactory();
_webClient = _webClientFactory.Create();
_currentState = UpdateState.None;
// TempFolder = rootDirectory;
TempFolder = Path.Combine(Path.GetTempPath(), TEMP_FOLDER_NAME);
}
protected override void Update(UpdateState state)
{
if (state.PlayerInput[PlayerIndex.One].InputState.Buttons.Back.OnPressed)
this.Shutdown();
}
private void SetUpdateProgress(int updatedItemCount = 0, int totalUpdateItemCount = 0, UpdateState updateState = UpdateState.Default)
{
int progress = 0;
string message = "";
if (totalUpdateItemCount > 0)
progress = (int)(100.0f * (float)updatedItemCount / (float)totalUpdateItemCount);
if (updateState == UpdateState.Default)
{
switch (_state)
{
case NovelState.Active:
updateState = UpdateState.Waiting;
break;
case NovelState.Completed:
updateState = UpdateState.Completed;
break;
case NovelState.Inactive:
updateState = UpdateState.Inactive;
break;
case NovelState.Dropped:
updateState = UpdateState.Dropped;
break;
}
}
switch (updateState)
{
case UpdateState.Waiting:
progress = 0;
message = "Waiting For Updates";
break;
case UpdateState.Checking:
progress = 0;
message = "Checking For Updates";
break;
case UpdateState.Fetching:
message = "Fetching Updates: " + updatedItemCount + " / " + totalUpdateItemCount;
break;
case UpdateState.UpToDate:
if (_state == NovelState.Active)
message = "Novel Up To Date";
else if(_state == NovelState.Completed)
message = "Complted Novel Up To Date";
else if (_state == NovelState.Inactive)
message = "Inactive Novel Up To Date";
else if (_state == NovelState.Dropped)
message = "Dropped Novel Up To Date";
progress = 100;
break;
case UpdateState.Completed:
progress = 100;
message = "Novel Completed";
break;
case UpdateState.Inactive:
progress = 0;
message = "Novel Inactive";
break;
case UpdateState.Dropped:
progress = 0;
message = "Novel Dropped";
break;
}
if (BackgroundService.Instance.novelReaderForm != null && BackgroundService.Instance.novelReaderForm.InvokeRequired)
{
BackgroundService.Instance.novelReaderForm.BeginInvoke(new System.Windows.Forms.MethodInvoker(delegate
{
UpdateProgress = new Tuple<int, string>(progress, message);
}));
}
else
{
UpdateProgress = new Tuple<int, string>(progress, message);
}
}
private void OnMouse(UIMouseEventType type, UpdateState state)
{
}
//WIP test stuff. needs Yes/No Alerts.
public void MCUpdate(UpdateState update)
{
Async(new AsyncHandler(hi));
}
/// <summary></summary>
/// <param name="state"></param>
/// <param name="input"></param>
protected override sealed void Update(UpdateState state, InputState input)
{
Vector2 r = input.ThumbSticks.RightStick * (rotAcceleration * rotAcceleration * 0.05f + new Vector2(1, 1));
viewRotation += r * RotationSensitivity * 0.04f;
float cap = v_cap;
if (viewRotation.Y > cap)
viewRotation.Y = cap;
if (viewRotation.Y < -cap)
viewRotation.Y = -cap;
rotAcceleration += input.ThumbSticks.RightStick * (new Vector2(0.5f, 0.25f) * (1.5f - move.Length() * 0.5f)) * 1.25f;
rotAcceleration *= 0.9f;
#if !XBOX360
if (state.PlayerInput[PlayerIndex].ControlInput == ControlInput.KeyboardMouse)
rotAcceleration *= 0;//no rotation acceleration for mouse
#endif
move *= 0.75f;
move += input.ThumbSticks.LeftStick / 4;
if (rotAcceleration.LengthSquared() > 0 && r.LengthSquared() > 0)
{
Vector2 v1 = rotAcceleration, v2 = r;
v1.Normalize();
v2.Normalize();
float a = Vector2.Dot(v1, v2);
if (a > 0)
rotAcceleration *= a;
else
rotAcceleration *= 0.25f;
}
Matrix m1, rotation;
if (zUp)
{
//z is up, so rotate left/right is around z.
Matrix.CreateRotationZ(-viewRotation.X, out rotation);
//x is always left to right, so rotate up/down is around x
Matrix.CreateRotationX(viewRotation.Y + MathHelper.PiOver2, out m1);
}
else
{
//y is up, so rotate left/right is around y.
Matrix.CreateRotationY(-viewRotation.X, out rotation);
Matrix.CreateRotationX(viewRotation.Y, out m1);
}
Matrix.Multiply(ref m1, ref rotation, out rotation);
Vector3 pos = Position;
pos -= (rotation.Forward * move.Y * MovementSensitivity.Y * -8 + rotation.Left * move.X * MovementSensitivity.X * 8);// new Vector3(move.X * -8, 0, move.Y * 8);
Matrix.CreateTranslation(ref pos, out m1);
Matrix.Multiply(ref rotation, ref m1, out rotation);
CameraMatrix = rotation;
}
public UpdateFrequency Update(UpdateState state)
{
Vector3 color = new Vector3(0.08f, 0.08f, 0.08f);
if (Highlight)
color = new Vector3(0.15f, 0.5f, 0.05f);
this.Colour = this.Colour * 0.75f + color * 0.25f;
Vector3 half = Vector3.One * 0.5f;
background[0].Colour = new Color(this.Colour * Fade);
background[2].Colour = new Color(new Vector3(0.25f, 0.25f, 0.25f) * Fade + half * (1 - Fade));
background[1].Colour = new Color(new Vector3(1, 1, 1) * Fade + half * (1-Fade));
text.ColourFloat = new Vector4(this.Colour + Vector3.One * 0.5f, Fade);
return UpdateFrequency.OncePerFrame;
}
private void Update(UpdateState state)
{
Vector2 pt = Target.GetMousePosition(state.MouseState);
var pt2 = new Microsoft.Xna.Framework.Point((int)pt.X, (int)pt.Y);
if (m_active)
{
if (m_fade < 1) m_fade += 0.1f;
if (m_fade > 1) m_fade = 1;
GameFacade.Screens.TooltipProperties.UpdateDead = false;
GameFacade.Screens.TooltipProperties.Position = m_position;
GameFacade.Screens.TooltipProperties.Opacity = m_fade;
/** fade in **/
if (!Target.GetBounds().Contains(pt2) || !GameFacade.Focus || !Target.WillDraw())
{
m_active = false;
GameFacade.Screens.TooltipProperties.Show = false;
GameFacade.Screens.TooltipProperties.Opacity = 0;
m_fade = 0;
}
}
else
{
if (Target.GetBounds().Contains(pt2) && Target.Tooltip != null && Target.WillDraw() && GameFacade.Focus)
{
m_active = true;
GameFacade.Screens.TooltipProperties.Show = true;
GameFacade.Screens.TooltipProperties.Opacity = 0;
GameFacade.Screens.TooltipProperties.UpdateDead = false;
GameFacade.Screens.Tooltip = Target.Tooltip;
m_fade = 0;
m_position = new Vector2(state.MouseState.X, Target.LocalPoint(new Vector2(0, 0)).Y); //at top of element
}
}
}
private void Update(UpdateState state)
{
if (m_doDrag)
{
/** Drag the dialog box **/
var position = DragControl.Parent.GetMousePosition(state.MouseState);
DragControl.X = position.X - m_dragOffsetX;
DragControl.Y = position.Y - m_dragOffsetY;
}
}
/// <summary> /// Called at the start of the update loop, 60 times per frame /// </summary> /// <param name="state"></param> protected internal abstract void Update(UpdateState state);
//This is the core of game logic in xen.
//The Update method returns an UpdateFrequency,
//This tells the update manager how often this object
//wishes to be updated. In this example, 'FullUpdate60hz' will
//be used, which indicates that Update() should be called 60
//times per second.
//NOTE: All player input is also updated at 60hz, so any class
//that deals with player input should also run at 60hz.
//
//There is a special value, UpdateFrequency.Terminate which
//can be returned. When used, the UpdateManager will remove
//the object from its internal list.
public UpdateFrequency Update(UpdateState state)
{
//Here, a reference to the state of the first players' input is retrieved
var playerInput = state.PlayerInput[PlayerIndex.One].InputState;
//The InputState object stores the state of a virtual gamepad.
//It stores all the values of a gamepad, such as
//playerInput.ThumbSticks.LeftStick. However, under the hood
//these values can be rewired. This can be done with the classes
//within the Input namespace.
//One example, is that the keyboard and mouse on the PC
//are emulated as a gamepad in xen, using the mouse and WASD by default.
//While the raw keyboard and mouse state are also available:
//state.KeyboardState
//state.MouseState
//state.GetGamePadState(...)
//NOTE: Using the XNA inbuilt 'GetState' methods such as
//GamePad.GetState() is *very* slow. Avoid them at all costs!
//With that said, the defaults control methods are: (For player one)
//
//Xbox360: No change, acts just like a gamepad
//Windows with a Gamepad: No change
//Windows without a Gamepad: Keyboard & mouse emulation
//This can be changed. Example, to force player one to use a gamepad:
//state.PlayerInput[PlayerIndex.One].ControlInput = Xen.Input.ControlInput.GamePad1;
//With a lot of mouse driven games, it is desirable to keep the mouse
//in the centre of the window, allowing greater freedom of movement.
//This allows the player to rotate as much as they want, without the mouse
//stopping at the edge of the screen:
//state.PlayerInput[PlayerIndex.One].InputMapper.CentreMouseToWindow = true;
//phew!
//now. the camera logic.
//rotation speed...
float sensitivity = 5;
//make sure it's scaled by the time step (in this case, it'll be 1/60)
sensitivity *= state.DeltaTimeSeconds;
//rotate the camera with the thumbstick movement
this.cameraRotation.X += playerInput.ThumbSticks.RightStick.X * sensitivity;
this.cameraRotation.Y += playerInput.ThumbSticks.RightStick.Y * sensitivity;
//clamp the rotation up/down
if (this.cameraRotation.Y > MathHelper.PiOver2)
this.cameraRotation.Y = MathHelper.PiOver2;
if (this.cameraRotation.Y < -MathHelper.PiOver2)
this.cameraRotation.Y = -MathHelper.PiOver2;
float viewDistance = 8;
//when the 'A' button is held down, bring the view closer.
//Note: with mouse/keyboard, button 'a' becomes the space bar (the default)
if (playerInput.Buttons.A.IsDown)
viewDistance = 6;
//example, to change the mapping from the space bar to the enter key:
//
//state.PlayerInput[PlayerIndex.One].KeyboardMouseControlMapping.A =
// Microsoft.Xna.Framework.Input.Keys.Enter;
//this is a fairly nasty way to generate the camera matrix :-)
Matrix cameraMatrix =
Matrix.CreateTranslation(0, 0, viewDistance) * //move +viewDistance on the z-axis (negative z-axis is into the screen, so positive moves away)
Matrix.CreateRotationX(this.cameraRotation.Y + MathHelper.PiOver2) * // rotate up/down around x-axis (the model is rotated 90 deg, hence the PiOver2)
Matrix.CreateRotationZ(this.cameraRotation.X); //then finally rotate around the z-axis left/right
//update the camera matrix
this.camera.SetCameraMatrix(ref cameraMatrix);
//request that this object have Update called 60 times
//per second. Note that this value can be changed at will,
//So objects could update at different rates depending on
//how close they are to the player, etc.
return UpdateFrequency.FullUpdate60hz;
}
/// <summary>
/// Simple path following. If within "snap distance" of a the nextGoal (a NavNode)
/// move to the NavNode, get a new nextGoal, turnToFace() that goal. Otherwise
/// continue making steps towards the nextGoal.
/// </summary>
public override void Update(GameTime gameTime)
{
KeyboardState keyboardState = Keyboard.GetState();
if ((keyboardState.IsKeyDown(Keys.N) && !oldKeyboardState.IsKeyDown(Keys.N)) && currentState == UpdateState.PATH_FOLLOWING)
currentState = UpdateState.TREASURE_GOAL; // toggle NPAgent update state.
float distance;
switch(currentState)
{
case UpdateState.PATH_FOLLOWING :
agentObject.turnToFace(nextGoal.Translation); // adjust to face nextGoal every move
// See if at or close to nextGoal, distance measured in 2D xz plane
distance = Vector3.Distance(
new Vector3(nextGoal.Translation.X, 0, nextGoal.Translation.Z),
new Vector3(agentObject.Translation.X, 0, agentObject.Translation.Z));
stage.setInfo(15, stage.agentLocation(this));
stage.setInfo(16,
string.Format(" nextGoal ({0:f0}, {1:f0}, {2:f0}) distance to next goal = {3,5:f2})",
nextGoal.Translation.X/stage.Spacing, nextGoal.Translation.Y, nextGoal.Translation.Z/stage.Spacing, distance) );
if (distance <= snapDistance) {
// snap to nextGoal and orient toward the new nextGoal
nextGoal = path.NextNode;
// agentObject.turnToFace(nextGoal.Translation);
}
oldKeyboardState = keyboardState; // Update saved state.
base.Update(gameTime); // Agent's Update();
break;
case UpdateState.TREASURE_GOAL :
agentObject.turnToFace(new Vector3(67050,100,67950)); // adjust to face nextGoal every move
// See if at or close to nextGoal, distance measured in 2D xz plane
distance = Vector3.Distance(
new Vector3(67050,0,67950),
new Vector3(agentObject.Translation.X, 0, agentObject.Translation.Z));
stage.setInfo(15, stage.agentLocation(this));
//stage.setInfo(16,
// string.Format(" nextGoal ({0:f0}, {1:f0}, {2:f0}) distance to next goal = {3,5:f2})",
// nextGoal.Translation.X/stage.Spacing, nextGoal.Translation.Y, nextGoal.Translation.Z/stage.Spacing, distance) );
if (distance <= 300) {
// snap to nextGoal and orient toward the new nextGoal
//nextGoal = path.NextNode;
currentState = UpdateState.PATH_FOLLOWING;
// agentObject.turnToFace(nextGoal.Translation);
}
oldKeyboardState = keyboardState; // Update saved state.
base.Update(gameTime); // Agent's Update();
break;
}
}
public void ButtonAnim(UpdateState state)
{
icon.button.Selected = false;
if (Alert && Ticks < 30) icon.button.Selected = true;
if (++Ticks > 59)
{
Ticks = 0;
}
}
protected override void Update(UpdateState state)
{
menuBlock.Position = new Vector2(ElementXOffset, -(ElementYOffset + (int)menuVerticalScroll));
if (state.PlayerInput[PlayerIndex.One].InputState.Buttons.DpadDown.IsPressedRepeats(state, 0.1f, 0.15f))
selection++;
if (state.PlayerInput[PlayerIndex.One].InputState.Buttons.DpadUp.IsPressedRepeats(state, 0.1f, 0.15f))
selection--;
if (selection < 0) selection = 0;
if (selection >= buttons.Count) selection = buttons.Count - 1;
float selection_y = (ElementYOffset + ElementHeight * 0.5f + ElementSeparation * selection);
float y_offset = selection_y - MaxScrollDown;
if (y_offset < 0) y_offset = 0;
menuVerticalScroll = y_offset * -0.2f + menuVerticalScroll * 0.8f;
foreach (var item in buttons)
{
float y = item.YPos - menuBlock.Position.Y;
item.Highlight = false;
item.Fade = 1;
if (y > FadeOutStart) item.Fade = 1 - (y - FadeOutStart) / (FadeOutEnd - FadeOutStart);
if (y < FadeInStart)
item.Fade = 1 - (y - FadeInStart) / (FadeInEnd - FadeInStart);
if (item.Fade < 0) item.Fade = 0;
}
if (buttons.Count > 0)
buttons[selection].Highlight = true;
this.backgroundParticles.GlobalValues[1] = WindowHeight - selection_y - menuVerticalScroll;
if (buttons.Count > 0 && state.PlayerInput[PlayerIndex.One].InputState.Buttons.A.OnPressed)
{
selectedTutorial = buttons[selection].Value;
this.Shutdown();
}
else
if (state.PlayerInput[PlayerIndex.One].InputState.Buttons.Back.OnPressed)
{
selectedTutorial = null;
this.Shutdown();
}
}
/// <summary>
/// Handle mouse events for dragging
/// </summary>
/// <param name="evt"></param>
private void DragMouseEvents(UIMouseEventType evt, UpdateState state)
{
switch (evt)
{
case UIMouseEventType.MouseDown:
/** Start drag **/
m_doDrag = true;
DragControl.AddUpdateHook(UpdateHook);
var position = DragControl.GetMousePosition(state.MouseState);
m_dragOffsetX = position.X;
m_dragOffsetY = position.Y;
break;
case UIMouseEventType.MouseUp:
/** Stop drag **/
m_doDrag = false;
DragControl.RemoveUpdateHook(UpdateHook);
break;
}
}
//internal update method
UpdateFrequency IUpdate.Update(UpdateState state)
{
if (disposed)
return UpdateFrequency.Terminate;
if (systemData == null)
return UpdateFrequency.FullUpdate60hz;
//draw proc only makes it's callback if system isn't null
drawProc.system = null;
if (enabled)
{
//system logic is performed as a thread task
threadWaitCallback.WaitForCompletion();
if (!pauseUpdatesWhileCulled ||
this.drawProc.AnyChildDrawnLastFrame)
{
//particle system is enabled, and isn't offscreen
BufferSpawnData();
//start the task
threadWaitCallback = state.Application.ThreadPool.QueueTask(threadAction, null);
//draw proc only makes it's callback if system isn't null
drawProc.system = this;
}
}
//asks the application to call Draw() on the drawProc when the frame begins
//as currnetly in update()
state.PreFrameDraw(drawProc);
return systemLogic.UpdateFrequency;
}
internal void CallUpdate(UpdateState state)
{
((IUpdate)updateManager).Update(state);
}
/// <summary> /// Update method to implement /// </summary> /// <param name="state"></param> /// <param name="input"></param> protected abstract void Update(UpdateState state, InputState input);
UpdateFrequency IUpdate.Update(UpdateState state)
{
this.Update(state);
return UpdateFrequency.FullUpdate60hz;
}
private void MouseEvt(UIMouseEventType type, UpdateState state)
{
if (type == UIMouseEventType.MouseDown) OnMouseEvent(this); //pass to parents to handle
}
public override void Update(UpdateState GState)
{
}