private void Edit_Events(object sender, MouseButtonEventArgs e)
{
try
{
DataGrid dg = sender as DataGrid;
EventsDataGrid p = (EventsDataGrid)dg.SelectedItems[0]; // OR: Patient p = (Patient)dg.SelectedItem;
UpdateEvent up = new UpdateEvent(p, StaffRole);
if (p.EventStartDateTime.Hour >= 12)
{
up.AMPM_Start.SelectedIndex = 1;
}
else
{
up.AMPM_Start.SelectedIndex = 0;
}
if (p.EventEndDateTime.Hour >= 12)
{
up.AMPM_End.SelectedIndex = 1;
}
else
{
up.AMPM_End.SelectedIndex = 0;
}
up.DateRecieved.SelectedDate = p.EventStartDateTime;
up.ShowDialog();
}
catch (Exception error)
{
}
Refresh_Events(sender, e);
}
private void Update(UpdateEvent ev)
{
if (!foundGoal && World.LevelNum > 0)
{
var goal = EnumerateObjects<LevelEnd>().FirstOrDefault();
if (goal != null)
{
startMove = goal.WorldCoord;
foundGoal = true;
}
}
if (GameStarted && Player != null && !Player.Enabled)
{
for (int i=InterfaceElements.Count - 1; i >= 0; i--)
{
InterfaceElements[i].Opacity -= ev.DeltaTime;
if (InterfaceElements[i].Opacity <= 0f)
{
InterfaceElements[i].Remove();
InterfaceElements.RemoveAt(i);
}
}
if (InterfaceElements.Count == 0)
{
if (!isFirstStep)
moveProgress += ev.DeltaTime * 0.66f;
if (moveProgress < 0f)
{
Camera.WorldCoord = startMove;
}
else
{
Camera.WorldCoord = (startMove + (Player.WorldCoord - startMove) * (Mathf.Sin(-Mathf.HalfPi + moveProgress * Mathf.Pi) + 1f) / 2f - Engine.Resolution / 2f);
Camera.WorldCoord = new Vector2((int)Camera.WorldCoord.X, (int)Camera.WorldCoord.Y);
Camera.WorldCoord += Engine.Resolution / 2f;
var move = (Player.WorldCoord - Camera.WorldCoord).Unit * 200f * ev.DeltaTime;
if (moveProgress >= 1f)
Player.Enabled = true;
}
}
}
if (Player != null && Player.Stun == 0f && Player.Enabled)
{
Camera.WorldCoord = Player.WorldCoord;
var camera = Camera.WorldCoord - Engine.Resolution / 2f;
if (camera.X < 0f)
camera.X = 0f;
if (camera.X + Engine.Resolution.X > World.SolidsWidth)
camera.X = World.SolidsWidth - Engine.Resolution.X;
Camera.WorldCoord = camera + Engine.Resolution / 2f;
}
isFirstStep = false;
}
public PCTimer(UpdateEvent updateEvent)
{
timer= new InternalClock();
update= updateEvent;
prevTime= DateTime.Now;
time= new GameTime(DateTime.Now-prevTime);
Wfx.Application.Idle+= onIdle;
}
public GameUpdater(int pFPS, UpdateEvent updateCall)
{
updateTimer= new GameClock();
update= updateCall;
prevTime= DateTime.Now;
time= new GameTime(DateTime.Now-prevTime);
framesPerSecond= pFPS;
Application.Idle+= appIdle;
}
public Main()
{
if (tMain != null)
throw new Exception();
tMain = this;
BitsWrittenUpdatedMethod = this.UpdateBitsWritten;
InitializeComponent();
}
public void AddEnemies(int id, int count, Vector3 pos, float disTime)
{
paramCount = count;
paramDisTime = disTime;
paramPos = pos;
paramEnemyID = id;
waitEvent = EventAddEnemy;
StartCoroutine(waitEvent());
}
public void HeartbeatIntervalTest()
{
UpdateEvent target = new UpdateEvent(); // TODO: Initialize to an appropriate value
int expected = 0; // TODO: Initialize to an appropriate value
int actual;
target.HeartbeatInterval = expected;
actual = target.HeartbeatInterval;
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
public BackgroundUpdater(WatcherView view, WatcherViewModel viewModel, WatcherController controller)
{
this.viewModel = viewModel;
worker = new BackgroundWorker();
worker.DoWork += worker_DoWork;
UpdateStarted += view.StartUpdating;
UpdateCompleted += view.FinishUpdating;
Update += controller.UpdateBuilds;
}
public void GetDates(UpdateEvent eventObj)
{
JObject jsonObj = JObject.Parse(System.Text.Encoding.UTF8.GetString(eventObj.getUpdate(), 0, eventObj.getUpdate().Length));
ClickPos.X = int.Parse(jsonObj["X"].ToString());
ClickPos.Y = int.Parse(jsonObj["Y"].ToString());
this.GetMoveDir(ClickPos);
}
public void onUpdatePeersReceived(UpdateEvent eventObj)
{
//string j = System.Text.UTF8Encoding.UTF8.GetString(eventObj.getUpdate(), 0, eventObj.getUpdate().Length);
// _page.showResult("update recvd " + j );
//JObject jsonObj = JObject.Parse(System.Text.Encoding.UTF8.GetString(eventObj.getUpdate(), 0, eventObj.getUpdate().Length));
//string name = System.Text.Encoding.UTF8.GetString(eventObj.getUpdate(), 0, eventObj.getUpdate().Length);
//_page.showResult(name);
//game_page.SendTxt = "Send";
//game_page.Vect(eventObj);
}
private void WoodBlock_OnAdditionEnd(Actor actor, Buff skill, bool cancel)
{
((ActorExt)actor).Status.Dummy = false;
Map.Map map = MapManager.Instance.GetMap(actor.MapInstanceID);
((ActorExt)actor).Tasks.TryRemove("CounterEnemy", out Task removed);
UpdateEvent evt = UpdateEvent.NewActorAdditionEvent((ActorExt)actor, (ActorExt)actor, arg.SkillSession, 1, 15111010, UpdateEvent.ExtraUpdateModes.Cancel);
evt.UserData = new byte[] { 9, 1, 0 };
//evt.AddActorPara(SagaBNS.Common.Packets.GameServer.PacketParameter.BlockingStance, 0);
map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, actor, true);
evt = UpdateEvent.NewActorAdditionExtEvent((ActorExt)actor, arg.SkillSession, 1, 15111010, 0, UpdateEvent.ExtraUpdateModes.Cancel);
map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, actor, true);
SkillManager.Instance.BroadcastSkillCast(arg, SkillMode.End);
}
public void UpdateTimer(UpdateEvent e, DialogNode dialog, [JoinAll] HomeScreenNode homeScreen, [JoinAll] SelfUserWithReservNode user)
{
int time = (int)(user.reservedInBattleInfo.ExitTime - Date.Now);
if (dialog.returnToBattleDialog.SecondsLeft != time)
{
dialog.returnToBattleDialog.SecondsLeft = time;
dialog.modalConfirmWindow.MainText = this.InsertLeftTime(dialog.returnToBattleDialog.PreformatedMainText, time);
if (dialog.returnToBattleDialog.SecondsLeft <= 0)
{
dialog.modalConfirmWindow.Hide();
base.ScheduleEvent <ReleaseReservationInBattleEvent>(user);
}
}
}
public void ChangeCombatStatus(bool combat)
{
if (chara.Status.IsInCombat != combat || !combat)
{
chara.Status.IsInCombat = combat;
UpdateEvent evt = new UpdateEvent()
{
Actor = chara,
Target = chara,
UpdateType = UpdateTypes.Actor
};
//evt.AddActorPara(PacketParameter.CombatStatus, combat ? 1 : 0);
map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, chara, true);
}
}
public void SendPlayerLevelUp()
{
UpdateEvent evt = new UpdateEvent()
{
Actor = chara,
Target = chara,
UpdateType = UpdateTypes.Actor
};
evt.AddActorPara(Common.Packets.GameServer.PacketParameter.Level, chara.Level);
evt.AddActorPara(PacketParameter.EXPBC, chara.Exp);
//evt.AddActorPara(PacketParameter.MaxHP, chara.MaxHP);
evt.AddActorPara(PacketParameter.HP, chara.HP);
map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, chara, true);
}
public void OnUpdate(UpdateEvent e)
{
if (!plugin.hasScp457 || DateTime.UtcNow < nextCheckTime)
{
return;
}
nextCheckTime = DateTime.UtcNow.AddSeconds(1);
// For each player that is an instance of SCP-457
foreach (Scp457Controller scp457Controller in plugin.GetScp457Controllers())
{
scp457Controller.AffectPlayers();
scp457Controller.DecreaseAbilities();
}
}
public static void INNIT(ChewChew yumyum)
{
GameObject broadCast = new GameObject("MousePosBroadCaster");
MouseRayBroadCaster 广播者 = broadCast.AddComponent <MouseRayBroadCaster>();
yumyumyum = yumyum;
GameObject ShowUpAll = GameObject.CreatePrimitive(PrimitiveType.Sphere);
StatMaster.DontDestroyOnLoad(ShowUpAll);
ShowUpAlll = ShowUpAll.AddComponent <ClickButtonBall>();
UpdateEvent EUSUA = new UpdateEvent(ShowThemAll);
ShowUpAlll.SetUp(Color.red, Color.white, true, false, "Show Camera \n Tracking Menu", EUSUA, new Vector3(0, 40, 35), new Vector3(0, 40, -15));
ShowUpAlll.Show();
广播者.AddMeIn(ShowUpAlll);
GameObject SetTriggerKey = GameObject.CreatePrimitive(PrimitiveType.Cube);
StatMaster.DontDestroyOnLoad(SetTriggerKey);
TriggerSetter = SetTriggerKey.AddComponent <KeyAssignButtonBall>();
UpdateEvent EUTS = new UpdateEvent(UpdateKey);
TriggerSetter.SetUp(Color.cyan, Color.red, KeyCode.RightAlt, "Key For \nTracking: {0}", EUTS, new Vector3(20, 40, 15), new Vector3(120, 120, -150));
广播者.AddMeIn(TriggerSetter);
GameObject SetOffKey = GameObject.CreatePrimitive(PrimitiveType.Cube);
StatMaster.DontDestroyOnLoad(SetOffKey);
TriggerOffSetter = SetOffKey.AddComponent <KeyAssignButtonBall>();
UpdateEvent EUTOS = new UpdateEvent(UpdateOffKey);
TriggerOffSetter.SetUp(Color.cyan, Color.red, KeyCode.Mouse1, "Key For Disable\nTracking: {0}", EUTOS, new Vector3(40, 40, 15), new Vector3(120, 130, -150));
广播者.AddMeIn(TriggerOffSetter);
GameObject ActivationRangeBall = GameObject.CreatePrimitive(PrimitiveType.Capsule);
StatMaster.DontDestroyOnLoad(ActivationRangeBall);
ActivationRange = ActivationRangeBall.AddComponent <SliderButtonBall>();
UpdateEvent EUAR = new UpdateEvent(UpdateActivationRange);
ActivationRange.SetUp(1, 100, 35, 0.1f, "Track when target \nat {0}% on the screen", EUAR, new Vector3(15, 60, 25), new Vector3(120, 140, -150));
广播者.AddMeIn(ActivationRange);
}
private void ActorItemPickDropTask_OnAdditionStart(SmartEngine.Network.Map.Actor actor, Buff skill)
{
Map.Map map = MapManager.Instance.GetMap(pc.MapInstanceID);
switch (action)
{
case ActionTypes.Pick:
{
UpdateEvent evt = new UpdateEvent()
{
UpdateType = UpdateTypes.ItemPick,
Actor = pc,
Target = item,
UserData = (byte)0
};
map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, pc, true);
}
break;
case ActionTypes.PickCorpse:
{
UpdateEvent evt = new UpdateEvent()
{
UpdateType = UpdateTypes.ItemPickCorpse,
Actor = pc,
Target = item,
UserData = (byte)0
};
map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, pc, true);
}
break;
case ActionTypes.Drop:
{
UpdateEvent evt = new UpdateEvent()
{
UpdateType = UpdateTypes.ItemDrop,
Actor = pc,
Target = item,
X = (short)item.X,
Y = (short)item.Y,
Z = (short)item.Z,
UserData = (byte)0
};
map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, pc, true);
}
break;
}
}
public override void CallBack()
{
Deactivate();
actor.Tasks.TryRemove("Respawn", out Task task);
Map.Map map = Map.MapManager.Instance.GetMap(actor.MapInstanceID);
actor.Available = true;
actor.Items = null;
UpdateEvent evt = new UpdateEvent()
{
Actor = actor,
UpdateType = UpdateTypes.MapObjectVisibilityChange
};
map.SendEventToAllActors(MapEvents.EVENT_BROADCAST, evt, actor, true);
}
private void Frost_OnAdditionStart(Actor actor, Buff skill)
{
target.Status.Invincible = true;
Map.Map map = Map.MapManager.Instance.GetMap(actor.MapInstanceID);
target.Status.StanceFlag1.SetValue(StanceU1.Unknown10000000, true);
target.Status.StanceFlag1.SetValue(StanceU1.NoMove, true);
target.Status.StanceFlag1.SetValue(StanceU1.Unknown200, true);
UpdateEvent evt = UpdateEvent.NewActorAdditionEvent(arg.Caster, (ActorExt)actor, arg.SkillSession, 4104, 12237012, UpdateEvent.ExtraUpdateModes.Activate);
//evt.AddActorPara(SagaBNS.Common.Packets.GameServer.PacketParameter.Unk7A, target.Status.StanceFlag1.Value);
//evt.AddActorPara(SagaBNS.Common.Packets.GameServer.PacketParameter.UnkE9, 1);
map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, actor, true);
}
public void AddGrenade(GrenadeConfig type)
{
if (Grenades.TryFind(item => item.type == type, out var slot))
{
slot.amount++;
}
else
{
Grenades.Add(new GrenadeSlot
{
type = type,
amount = 1
});
}
UpdateEvent?.Invoke();
}
public void OnQuestUpdateRequestMapObject(CM_QUEST_UPDATE_REQUEST_MAPOBJECT p)
{
if (currentMapObj != null && currentMapObj.ActorID == p.NpcActorID)
{
DoOperateMapObject(currentMapObj);
UpdateEvent evt = new UpdateEvent()
{
Actor = currentMapObj,
UpdateType = UpdateTypes.MapObjectDoQuest,
UserData = p.QuestID,
UserData2 = (ushort)(p.Unknown << 8 | p.Step)
};
map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, currentMapObj, true);
}
}
public void OnUpdate(UpdateEvent ev)
{
if (DateTime.Now > nextUpdate && plugin.hasConnectedOnce)
{
// Update player count
if (plugin.GetConfigString("discord_activity_playercount") == "on")
{
plugin.RefreshBotActivity();
}
// Update channel topic
plugin.RefreshChannelTopic();
nextUpdate = DateTime.Now.AddSeconds(5);
}
}
public void Update(UpdateEvent currentEventViewModel)
{
Event target = new Event();
target = entities.Events.Where(p => p.Id == currentEventViewModel.Id).Include(e => e.eventType).Include(e => e.productionUnit).FirstOrDefault();
if (target != null)
{
target.date = currentEventViewModel.CurrentDate;
target.description = currentEventViewModel.Note;
target.details = currentEventViewModel.Details;
target.isOpen = currentEventViewModel.IsOpen;
}
entities.SaveChanges();
}
public void SendPlayerHP(bool sendMaxHP = false)
{
UpdateEvent evt = new UpdateEvent()
{
Actor = chara,
Target = chara,
UpdateType = UpdateTypes.Actor
};
evt.AddActorPara(Common.Packets.GameServer.PacketParameter.HP, chara.HP);
if (sendMaxHP)
{
//evt.AddActorPara(Common.Packets.GameServer.PacketParameter.MaxHP, chara.MaxHP);
map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, chara, true);
}
}
public void Update(UpdateEvent e, UserAsTank userAsTank)
{
if (userAsTank.mouseControlStateHolder.MouseControlAllowed)
{
if (InputManager.GetActionKeyDown(BattleActions.SHOW_SCORE))
{
Cursor.lockState = CursorLockMode.Confined;
Cursor.visible = true;
}
if (InputManager.GetActionKeyUp(BattleActions.SHOW_SCORE))
{
Cursor.lockState = CursorLockMode.Locked;
Cursor.visible = false;
}
}
}
private void Frost_OnAdditionEnd(Actor actor, Buff skill, bool cancel)
{
target.Status.Invincible = false;
target.Status.StanceFlag1.SetValue(StanceU1.Unknown10000000, false);
target.Status.StanceFlag1.SetValue(StanceU1.NoMove, false);
target.Status.StanceFlag1.SetValue(StanceU1.Unknown200, false);
Map.Map map = Map.MapManager.Instance.GetMap(actor.MapInstanceID);
((ActorExt)actor).Tasks.TryRemove("Frost", out Task removed);
UpdateEvent evt = UpdateEvent.NewActorAdditionEvent(arg.Caster, (ActorExt)actor, arg.SkillSession, 4104, 12237012, UpdateEvent.ExtraUpdateModes.Cancel);
//evt.AddActorPara(SagaBNS.Common.Packets.GameServer.PacketParameter.Unk7A, 0);
//evt.AddActorPara(SagaBNS.Common.Packets.GameServer.PacketParameter.UnkE9, 0);
map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, actor, true);
}
public void PlayTankFrictionSound(UpdateEvent evt, ReadyActiveTankFrictionSoundNode tank)
{
TankFrictionSoundBehaviour tankFrictionSoundBehaviour = tank.tankFrictionSoundEffectReady.TankFrictionSoundBehaviour;
if (tankFrictionSoundBehaviour.TriggerStay)
{
TankFrictionSoundEffectComponent tankFrictionSoundEffect = tank.tankFrictionSoundEffect;
Collider frictionCollider = tankFrictionSoundBehaviour.FrictionCollider;
if (frictionCollider == null)
{
this.StopSounds(tankFrictionSoundEffect);
}
else
{
Vector3 velocity = tank.rigidbody.Rigidbody.velocity;
if (frictionCollider.gameObject.layer == Layers.FRICTION)
{
this.SetMetallFriction(tankFrictionSoundEffect, velocity);
}
else
{
DustEffectBehaviour effect = tank.collisionDust.CollisionDustBehaviour.Effect;
if (effect == null)
{
this.StopSounds(tankFrictionSoundEffect);
}
else
{
DustEffectBehaviour.SurfaceType surface = effect.surface;
if (surface == DustEffectBehaviour.SurfaceType.Metal)
{
this.SetMetallFriction(tankFrictionSoundEffect, velocity);
}
else if (surface != DustEffectBehaviour.SurfaceType.Concrete)
{
this.StopSounds(tankFrictionSoundEffect);
}
else
{
this.SetStoneFriction(tankFrictionSoundEffect, velocity);
}
}
}
}
}
}
public void CheckWWWIsDone(UpdateEvent e, SingleNode <UrlLoaderComponent> loaderNode)
{
Loader loader = loaderNode.component.Loader;
if (loader.IsDone)
{
if (!string.IsNullOrEmpty(loader.Error))
{
this.HandleError(loaderNode, loader, $"URL: {loader.URL}, Error: {loader.Error}", loaderNode.component.NoErrorEvent);
}
else
{
base.Log.InfoFormat("LoadComplete: {0}", loader.URL);
base.ScheduleEvent <LoadCompleteEvent>(loaderNode);
}
}
}
private void Update(UpdateEvent updateEvent)
{
if (counter > 0 && counter % spawnEachFrame == 0)
{
counter++;
}
else
{
counter++;
return;
}
if (FloodFillDiagnoal() == true)
{
EventSystem <UpdateEvent> .UnregisterListener(Update);
}
}
/// <summary>
/// Called every Tick
/// </summary>
/// <param name="source"></param>
/// <param name="args"></param>
/// <returns>the amount of millseconds taken</returns>
protected long Update(object source, EventArgs args)
{
var time = DateTimeOffset.Now.ToUnixTimeMilliseconds();
CatchExceptions(HandleQueue);
CatchExceptions(() => UpdateEvent?.Invoke());
var taken = DateTimeOffset.Now.ToUnixTimeMilliseconds() - time;
var interval = CalculateInterval(tickRate.Value);
if (taken > interval)
{
App.Console.Print($"{Name} loop is running {taken - interval}ms behind!", Colors.Yellow);
}
return(taken);
}
public void UpdateTime(UpdateEvent e, BattleTimeIndicatorNode battleTimeIndicator, [JoinByBattle] BattleTimeNode battleTime, [JoinByBattle] RoundNode round)
{
float progress = 0f;
long timeLimitSec = battleTime.timeLimit.TimeLimitSec;
float timeSeconds = timeLimitSec;
if (battleTime.Entity.HasComponent <BattleStartTimeComponent>() && !round.Entity.HasComponent <RoundWarmingUpStateComponent>())
{
Date roundStartTime = battleTime.Entity.GetComponent <BattleStartTimeComponent>().RoundStartTime;
timeSeconds -= Date.Now - roundStartTime;
progress = Date.Now.GetProgress(roundStartTime, roundStartTime + timeLimitSec);
}
string timerText = TimerUtils.GetTimerText(timeSeconds);
battleTimeIndicator.battleTimeIndicator.Progress = 1f - progress;
battleTimeIndicator.battleTimeIndicator.Time = timerText;
}
public void ShowUpdateDetailWindow()
{
var window = new DetailUpdateWindow(
methodArgs as NewNameArgs);
if (window.ShowDialog() == true)
{
RaiseChangeEvent("Description");
var args = methodArgs as NewNameArgs;
UpdateEvent e1 = new UpdateEvent();
if (newNameEvent != null)
{
newNameEvent(args, e1);
}
e1 = null;
}
}
public RealtimeOhlc Update(IBfExecution exec)
{
ExecutionCount++;
if (exec.ExecutedTime < Start)
{
Start = exec.ExecutedTime;
Open = exec.Price;
}
if (exec.ExecutedTime > End)
{
End = exec.ExecutedTime;
Close = exec.Price;
}
High = Math.Max(High, exec.Price);
Low = Math.Min(Low, exec.Price);
switch (exec.Side)
{
case BfTradeSide.Buy:
BuyVolume += unchecked ((double)exec.Size);
break;
case BfTradeSide.Sell:
SellVolume += unchecked ((double)exec.Size);
break;
default:
ExecutedVolume += unchecked ((double)exec.Size);
break;
}
_amount += exec.Price * exec.Size;
try
{
VWAP = unchecked ((double)(_amount / unchecked ((decimal)Volume)));
}
catch (DivideByZeroException)
{
VWAP = 0;
}
UpdateEvent?.Invoke(this);
return(this);
}
public void OnExpandInventory()
{
int upgradecost = UpgradeCost(chara.InventorySize);
if (chara.Gold >= upgradecost && upgradecost != -1)
{
SM_EXPAND_INVENTORY r = new SM_EXPAND_INVENTORY();
Network.SendPacket(r);
chara.InventorySize += 8;
chara.Gold -= upgradecost;
SM_PLAYER_UPDATE_LIST p = new SM_PLAYER_UPDATE_LIST();
UpdateEvent evt = new UpdateEvent();
evt.AddActorPara(PacketParameter.Gold, chara.Gold);
evt.AddActorPara(PacketParameter.InventorySlots, chara.InventorySize);
p.Parameters = evt;
Network.SendPacket(p);
}
}
public void UpdateProgress(UpdateEvent e, CalculatedProgressBarNode node, [JoinAll] ICollection <SingleNode <ResourceLoadStatComponent> > loadStats, [JoinAll] ICollection <SingleNode <AssetBundleLoadingComponent> > assetBundlesLoading)
{
LoadBundlesTaskComponent loadBundlesTask = node.loadBundlesTask;
this.UpdateLoadBundlesTask(loadBundlesTask, loadStats);
node.loadBundlesTaskProvider.UpdateData(loadBundlesTask);
if (loadBundlesTask.AllBundlesLoaded())
{
base.Log.Info("ProgressComplete");
node.Entity.RemoveComponent <LoadBundlesTaskComponent>();
node.Entity.AddComponentIfAbsent <LoadProgressTaskCompleteComponent>();
}
else if (!node.Entity.HasComponent <LoadProgressTaskCompleteComponent>() && this.ShowLogIfTimeout(node.resourcesLoadProgressBar.ProgressBar.ProgressValue, loadBundlesTask, assetBundlesLoading))
{
base.Log.Info("LoadingComplete by timeout");
node.Entity.AddComponent <LoadProgressTaskCompleteComponent>();
}
}
public void InterpolateManualTargetingCamera(UpdateEvent evt, AimingWorkActivationStateNode weapon, [JoinAll] AimingCameraNode cameraNode)
{
MuzzleVisualAccessor accessor = new MuzzleVisualAccessor(weapon.muzzlePoint);
CameraComponent camera = cameraNode.camera;
Transform root = cameraNode.cameraRootTransform.Root;
ShaftAimingCameraComponent shaftAimingCamera = cameraNode.shaftAimingCamera;
float t = Mathf.Clamp01(weapon.shaftAimingWorkActivationState.ActivationTimer / weapon.shaftStateConfig.ActivationToWorkingTransitionTimeSec);
MuzzleLogicAccessor accessor2 = new MuzzleLogicAccessor(weapon.muzzlePoint, weapon.weaponInstance);
root.SetPositionSafe(Vector3.Lerp(shaftAimingCamera.WorldInitialCameraPosition, accessor2.GetBarrelOriginWorld(), t));
Quaternion quaternion2 = Quaternion.LookRotation(accessor.GetFireDirectionWorld(), accessor.GetUpDirectionWorld());
weapon.weaponRotationControl.MouseRotationCumulativeHorizontalAngle = Mathf.Clamp(weapon.weaponRotationControl.MouseRotationCumulativeHorizontalAngle, -weapon.shaftAimingRotationConfig.AimingOffsetClipping, weapon.shaftAimingRotationConfig.AimingOffsetClipping);
Vector3 eulerAngles = quaternion2.eulerAngles;
root.SetRotationSafe(Quaternion.Slerp(shaftAimingCamera.WorldInitialCameraRotation, Quaternion.Euler(eulerAngles.x, eulerAngles.y + weapon.weaponRotationControl.MouseRotationCumulativeHorizontalAngle, eulerAngles.z), t));
camera.FOV = Mathf.Lerp(shaftAimingCamera.InitialFOV, weapon.shaftAimingCameraConfigEffect.ActivationStateTargetFov, t);
}
public async Task UpdateById_NotFound_Result()
{
var options = new DbContextOptionsBuilder <DataBaseContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;;
var updateEventTest = new UpdateEvent {
Description = "UpdateTest1", DeadlineDate = 1560286800, IsComplete = false
};
var context = new DataBaseContext(options);
var service = new EventsController(context);
var result = await service.UpdateById(Guid.Parse("3fa85f64-5717-4562-b3fc-2c963f66afa6"), updateEventTest);
var notFoundResult = result as NotFoundResult;
Assert.IsNotNull(result);
Assert.AreEqual(404, notFoundResult.StatusCode);
}
public void onUpdatePeersReceived(UpdateEvent eventObj)
{
MoveMessage msg = MoveMessage.buildMessage(eventObj.getUpdate());
if (msg.type == "new")
{
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
_page.NewGame();
});
}
else
{
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
_page.UpdateUiFromMove(msg);
});
}
}
private void Frosen_OnAdditionEnd(Actor actor, Buff skill, bool cancel)
{
Map.Map map = Map.MapManager.Instance.GetMap(actor.MapInstanceID);
target.Status.StanceFlag1.SetValue(StanceU1.Unknown10000000, false);
target.Status.StanceFlag1.SetValue(StanceU1.Unknown400000, false);
target.Status.StanceFlag1.SetValue(StanceU1.Unknown4, false);
((ActorExt)actor).Tasks.TryRemove("Frosen", out Task removed);
target.Speed = 500;
UpdateEvent evt = UpdateEvent.NewActorAdditionEvent(arg.Caster, (ActorExt)actor, arg.SkillSession, 4101, 12000057, UpdateEvent.ExtraUpdateModes.Cancel);
//evt.AddActorPara(SagaBNS.Common.Packets.GameServer.PacketParameter.Speed, target.Speed / 10);
//evt.AddActorPara(SagaBNS.Common.Packets.GameServer.PacketParameter.Unk7A, 0);
map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, actor, true);
evt = UpdateEvent.NewActorAdditionExtEvent((ActorExt)actor, arg.SkillSession, 12, 12000057, 6000, UpdateEvent.ExtraUpdateModes.Cancel);
map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, actor, true);
}
public void Update(UpdateEvent e, SingleNode <AssetBundleDiskCacheComponent> cacheNode, [JoinAll] ICollection <SingleNode <AssetBundleLoadingComponent> > loadingBundleNodes)
{
cacheNode.component.AssetBundleDiskCache.Update();
foreach (SingleNode <AssetBundleLoadingComponent> node in loadingBundleNodes)
{
AssetBundleDiskCacheRequest assetBundleDiskCacheRequest = node.component.AssetBundleDiskCacheRequest;
if (assetBundleDiskCacheRequest.IsDone)
{
base.Log.InfoFormat("LoadComplete {0}", assetBundleDiskCacheRequest.AssetBundleInfo.Filename);
if (!string.IsNullOrEmpty(assetBundleDiskCacheRequest.Error))
{
this.HandleError(node.Entity, assetBundleDiskCacheRequest, assetBundleDiskCacheRequest.Error);
break;
}
base.ScheduleEvent <LoadCompleteEvent>(node.Entity);
}
}
}
public void onUpdatePeersReceived(UpdateEvent eventObj)
{
Log ("onUpdatePeersReceived");
OnlineMessage msg = OnlineMessage.DecodeMessage(eventObj.getUpdate());
if (msg.type == "new_match")
{
Application.LoadLevel (AppWarp.gameplaySceneStr);
if(AppWarp.isFirstPlayer) {
AppWarp.name_player2 = msg.sender;
// // Tell second player to start match
// AppWarp.warpClient.SendUpdatePeers(OnlineMessage.BuildBytes_NewMatch());
}
else {
AppWarp.name_player1 = msg.sender;
}
OnlineGameEvent ge = new OnlineGameEvent(EOnlineGameEvent.ONL_EVT_START_MATCH);
AppWarp.warpClient.SendUpdatePeers(OnlineMessage.BuildBytes_OnlineEvent(ge));
}
else if (msg.type == "oppName")
{
if(!AppWarp.isFirstPlayer) {
AppWarp.name_player1 = msg.sender;
}
}
else if (msg.type == "move")
{
if((AppWarp.isFirstPlayer && msg.sender != AppWarp.name_player1) ||
(!AppWarp.isFirstPlayer && msg.sender != AppWarp.name_player2)) {
// AppWarp.gameplayObj.UpdateSceneFromMove(msg);
}
}
else if (msg.type == "online_event")
{
if( msg.sender != AppWarp.localusername) {
OnlineGameEventsHandler.BroadcastEvent(msg.onlineEvent);
}
}
else {
Debug.Log ("Invalid Message Type Received");
}
}
private void Finish()
{
if (self.Status.CastingSkill)
{
UpdateEvent evt = new UpdateEvent()
{
Actor = self,
UpdateType = UpdateTypes.Skill,
Target = target,
Skill = curSkill,
SkillCastMode = SkillCastMode.Single,
SkillMode = SkillMode.End
};
map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, self, false);
self.Status.CastingSkill = false;
}
status = CommandStatus.Finished;
{
UpdateEvent evt = new UpdateEvent()
{
Actor = self,
Target = self,
UpdateType = UpdateTypes.Actor
};
//evt.AddActorPara(PacketParameter.CombatStatus, 0);
map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, self, false);
self.Status.IsInCombat = false;
evt = new UpdateEvent()
{
Actor = self,
Target = self,
UpdateType = UpdateTypes.Actor
};
//evt.AddActorPara(PacketParameter.FaceTo, 0);
map.SendEventToAllActorsWhoCanSeeActor(MapEvents.EVENT_BROADCAST, evt, self, false);
}
ai.DueTime = 100;
ai.Period = 100;
if (!ai.Activated && !ai.NoPlayer)
{
ai.Activate();
}
}
public void onUpdatePeersReceived(UpdateEvent eventObj)
{
//string j = System.Text.UTF8Encoding.UTF8.GetString(eventObj.getUpdate(), 0, eventObj.getUpdate().Length);
// _page.showResult("update recvd " + j );
//JObject jsonObj = JObject.Parse(System.Text.Encoding.UTF8.GetString(eventObj.getUpdate(), 0, eventObj.getUpdate().Length));
//JObject jsonObj = JObject.Parse(System.Text.Encoding.UTF8.GetString(eventObj.getUpdate(), 0, eventObj.getUpdate().Length));
try
{
GamePage.DatesList.Add(JObject.Parse(System.Text.Encoding.UTF8.GetString(eventObj.getUpdate(), 0, eventObj.getUpdate().Length)));
}
catch (Exception ex)
{
}
//JObject _GetObj = JObject.Parse(System.Text.Encoding.UTF8.GetString(eventObj.getUpdate(), 0, eventObj.getUpdate().Length));
//int it = int.Parse(_GetObj["Item"].ToString());
//int type = int.Parse(_GetObj["Type"].ToString());
//string name = System.Text.Encoding.UTF8.GetString(eventObj.getUpdate(), 0, eventObj.getUpdate().Length);
//_page.showResult(name);
//_game_page.SendTxt = "Send";
//GameTimerEventArgs e;
//_game_page.Vect(eventObj);
//_game_page.dir(e, new Vector2(3,3));
//if (it != GamePage.masItem)
//{
//if (type == 1)
//{
// GamePage.Balls_mas[it].GetClick(Ball._getObj);
//}
//else
//{
//GamePage.Balls_mas[it]._getObj = _GetObj;
//GamePage.Balls_mas[it].GetPos();
//}
//}
}
// Pre-initiates all the required things in the game
private void reqPreInit()
{
gdm= new GraphicsDeviceManager(this);
cameras= new SelectionList<Camera>(new Camera(this));
views= new SelectionList<Viewport>();
states= new GameStateManager(this);
registry= new Registry();
gui= new GuiManager();
clearColor= getColor("royalblue");
IsMouseVisible= true;
updateEvent= delegate(GameTime time) {};
drawEvent= delegate(GameTime time) {};
inputEvent= delegate(InputArgs args) {};
effects= new HashTable<Effect>(8);
textures= new HashTable<Texture2D>(8);
fonts= new HashTable<SpriteFont>(8);
videos= new HashTable<Video>(8);
sounds= new HashTable<SoundEffect>(8);
songs= new HashTable<Song>(8);
models= new HashTable<Model>(8);
lastScrollData= 0;
lastMousePosition= Mouse.GetState().Position;
}
// Sets a timeout event to be called after the given amount of milliseconds
public virtual void setTimeout(int timeout, UpdateEvent callbackEvent)
{
// Variables
Timers.Timer timer= new Timers.Timer(timeout);
timer.Elapsed+= delegate(object sender, Timers.ElapsedEventArgs args)
{
timer.Stop();
callbackEvent(null);
};
timer.Start();
}
/// <summary>
/// 全局CD 间隔结束回调
/// </summary>
private void CDDisFinished()
{
updateEvent += CDEffectEvent;
if (mWaitMask) mWaitMask.enabled = false;
isWaitCD = false;
}
public void Put(UpdateEvent request)
{
try
{
if (eventRepository.ContainsKey(request.Event.Id))
{
eventRepository.Save(request.Event);
var cacheKey = keyBuilder.Build(request, x => x.Event.Id).ToString();
RequestContext.RemoveFromCache(Cache, cacheKey);
}
}
catch (InvalidOperationException ex)
{
logger.Error(ex.ToString());
throw;
}
catch (ApplicationException ex)
{
logger.Error(ex.ToString());
throw;
}
catch (Exception ex)
{
logger.Error(ex.ToString());
throw;
}
}
private bool CDEffectEvent()
{
bool isCDFinish = false;
mCDMask.fillAmount = cdPercent;
if (cdPercent <= 0)
{
//Debug.Log("-----------cd finish");
isCDFinish = true;
updateEvent -= CDEffectEvent;
}
return isCDFinish;
}
public void onUpdatePeersReceived(UpdateEvent eventObj)
{
Log ("onUpdatePeersReceived");
m_apppwarp.onBytes(eventObj.getUpdate());
//Log("isUDP " + eventObj.getIsUdp());
}
void UpdatePlayerExp()
{
timePlayer += Time.deltaTime;
if (hisPlayerData.level < UD.level)
{
hisPlayerData.exp = (int)Mathf.Lerp(hisPlayerData.exp, hisPlayerData.expByNextLv, timePlayer);
playerSlot.SetSldOther(hisPlayerData.GetPercentByEXP());
if (timePlayer >= 0)
{
hisPlayerData.level++;
timePlayer = 0;
playerSlot.SetLevel("Lv." + hisPlayerData.level);
}
}
else if (hisPlayerData.exp < UD.exp)
{
hisPlayerData.exp = (int)Mathf.Lerp(hisPlayerData.exp, UD.exp, timePlayer);
playerSlot.SetSldOther(hisPlayerData.GetPercentByEXP());
}
else
{
updateEvent -= UpdatePlayerExp;
}
}
void OnEnable()
{
if (isUnlock)
{
updateEvent += HasMP;
updateEvent += CDEffectEvent;
manager.waitCDEvent += WaitCDDistance;
manager.cdFinishEvent += CDDisFinished;
}
}
//invoked when SendUpdatePeer pressed, the updates get to everybody in the room
public void onUpdatePeersReceived(UpdateEvent eventObj)
{
if (OnUpdatePeersReceived != null)
OnUpdatePeersReceived(eventObj);
}
//设置副将经验
public void SetLieutenant()
{
hisHeroData = UIBattleManager.instance.pnlPVE.historyDatas;
for (int i = 0; i < hisHeroData.Count; i++)
{
CommonSlot slot = KMTools.AddChild<CommonSlot>(grdHero.gameObject, m_heroButton);
slot.name += "i";
slot.SetNormal(null, null, hisHeroData[i].heroData.icon_middle, "Lv." + hisHeroData[i].level);
slot.SetOther("EXP+" + FM.heroExp, hisHeroData[i].GetPercentByEXP());
heroSlots.Add(slot);
}
m_heroButton.gameObject.SetActive(false);
grdHero.repositionNow = true;
updateEvent += UpdateLieutenantExp;
}
// Starts to initiate the game
private void startInit()
{
reqPreInit();
((PCGameWindow)(window.frame)).Load+= delegate(object sender, EventArgs args)
{
preInit();
preInitMods();
reqInitSounds();
initSounds();
initModSounds();
initTextures();
initModTextures();
reqInitFonts();
initFonts();
initModFonts();
initModels();
initModModels();
initMisc();
initModMisc();
initStates();
initModStates();
postInit();
postInitMods();
guiRenderEvent= gui.render;
guiUpdateEvent= gui.update;
guiInputEvent= gui.handleInput;
updater= new GameUpdater(0, onUpdate);
};
}
// Starts the pre-requisites to pre initiation of the game
private void reqPreInit()
{
properties= new Properties();
window= new GameFrame(this);
graphics= new GraphicsRenderer();
registry= new Registry();
gui= new GUIManager(this);
gstates= new GameStateManager(this);
mods= new ModManager();
GameInput.viewport= window.viewport;
gsmInputEvent= delegate(InputArgs args) {};
gsmUpdateEvent= delegate(GameTime time) {};
gsmRenderEvent= delegate(GameTime time) {};
}
void UpdateLieutenantExp()
{
timeHero += Time.deltaTime;
BattleStartHeroData hisHero;
for (int i = 0; i < hisHeroData.Count; i++)
{
hisHero = hisHeroData[i];
if (hisHero.level < hisHero.heroData.level)
{
hisHero.exp = (int)Mathf.Lerp(hisHero.exp, hisHero.expByNextLv, timeHero);
m_heroButton.SetSldOther(hisHero.GetPercentByEXP());
if (timeHero >= 0)
{
hisHero.level++;
timeHero = 0;
m_heroButton.SetLevel("Lv." + hisHero.level);
}
}
else if (hisHero.exp < hisHero.heroData.exp)
{
hisHero.exp = (int)Mathf.Lerp(hisHero.exp, hisHero.heroData.exp, timeHero);
m_heroButton.SetSldOther(hisHero.GetPercentByEXP());
}
else
{
updateEvent -= UpdateLieutenantExp;
}
}
}
//设置统领经验条
public void SetPlayerExp()
{
hisPlayerData = UIBattleManager.instance.pnlPVE.hisPlayerData;
playerSlot.SetOther("EXP+[03ff06]" + FM.playerExp + "[-]", hisPlayerData.GetPercentByEXP());
playerSlot.SetLevel("Lv." + hisPlayerData.level);
updateEvent += UpdatePlayerExp;
}
public void onUpdatePeersReceived(UpdateEvent eventObj){}
/// <summary>
/// 每帧更新事件
/// </summary>
private bool HasMP()
{
//MP 足够为 true TODO
if (skillData.hero == null)
{
return false;
}
bool hasMP = skillData.hero.getCurPro((int)GlobalDef.NewHeroProperty.PRO_MANAPOINT) >= skillData.consume;
if (hasMP)
{
// MP的罩
mMPMask.enabled = false;
this.hasMP = true;
//Debug.Log("----------------has mp", gameObject);
}
else
{
// 去掉MP的罩
mMPMask.enabled = true;
this.hasMP = false;
//Debug.Log("-------------not mp", gameObject);
}
updateEvent -= HasMP;
return hasMP;
}
public void onUpdatePeersReceived(UpdateEvent eventObj)
{
Log ("onUpdatePeersReceived");
}
