public void Update(double deltaTime)
{
_isEventPause = _inputManager.RightTrigger;
_isFreeCam = _inputManager.LeftTrigger;
if (_eventPlayer != null && _isEventPause == false)
{
_eventPlayer.Update(deltaTime);
if (_eventPlayer.IsEnd)
{
FadeFromBlack(1);
_eventPlayer = null;
}
}
foreach (var entity in _actors.Where(x => x.IsMeshLoaded && x.IsVisible))
{
entity.Update((float)deltaTime);
}
if (_isFading)
{
UpdateFade(deltaTime);
}
}
public void LoadMapArd(int worldIndex, int placeIndex)
{
_kernel.DataContent
.FileOpen($"msg/{_kernel.Language}/{Constants.WorldIds[worldIndex]}.bar")
.Using(stream => Bar.Read(stream))
.ForEntry(x => x.Type == Bar.EntryType.List, stream =>
{
_eventMessageProvider.Load(Msg.Read(stream));
return(true);
});
string fileName;
if (_kernel.IsReMix)
{
fileName = $"ard/{_kernel.Language}/{Constants.WorldIds[worldIndex]}{placeIndex:D02}.ard";
}
else
{
fileName = $"ard/{Constants.WorldIds[worldIndex]}{placeIndex:D02}.ard";
}
_eventPlayer = null;
RemoveAllActors();
_binarcArd = _kernel.DataContent.FileOpen(fileName).Using(Bar.Read);
Events = _binarcArd
.Where(x => x.Type == Bar.EntryType.AnimationLoader)
.Select(x => x.Name)
.ToList();
RunSpawnScript(_binarcArd, "map", _spawnScriptMap);
RunSpawnScript(_binarcArd, "btl", _spawnScriptBtl);
RunSpawnScript(_binarcArd, "evt", _spawnScriptEvt);
}
public void CreateTimeSeriesSubscriptionTest()
{
var symbol = "SYMA";
var s = DXEndpoint.Create().Feed.CreateTimeSeriesSubscription <IDxCandle>();
s.AddSymbols(symbol);
TestListener eventListener = new TestListener();
s.AddEventListener(eventListener);
var playedCandle = new PlayedCandle(symbol, Tools.DateToUnixTime(DateTime.Now), 123, 100, 12.34, 56.78, 9.0, 43.21, 1000, 999, 1001, 1002, 1, 777, 888, EventFlag.RemoveSymbol);
EventPlayer <IDxCandle> eventPlayer = new EventPlayer <IDxCandle>(s as DXFeedSubscription <IDxCandle>);
eventPlayer.PlayEvents(symbol, playedCandle);
Assert.AreEqual(eventListener.GetEventCount <IDxCandle>(symbol), 1);
IDxCandle receivedCandle = eventListener.GetLastEvent <IDxCandle>().Event;
Assert.AreEqual(symbol, receivedCandle.EventSymbol.ToString());
CompareCandles(playedCandle, receivedCandle);
//thread-safety case
DXEndpoint.Create();
Parallel.For(ParallelFrom, ParallelTo, i =>
{
Assert.DoesNotThrow(() =>
{
DXEndpoint.GetInstance().Feed.CreateTimeSeriesSubscription <IDxCandle>();
});
});
}
protected override void AddPlayers(EventPlayer player)
{
player.Add <SessionDeleted>(e => _isDeleted = true)
.Add <SessionUpdated>(e =>
{
_lastUpdate = e;
TrainerId = e.TrainerId;
LocationId = e.LocationId;
SessionStart = e.SessionStart;
Duration = e.Duration;
_availableSeats = e.Seats;
})
.Add <SessionCanceled>(e => _isCanceled = true)
.Add <SessionPlanned>(e =>
{
_availableSeats = e.Seats;
TrainerId = e.TrainerId;
LocationId = e.LocationId;
SessionStart = e.SessionStart;
Duration = e.Duration;
})
.Add <SessionSeatBooked>(e =>
{
_bookedSeats++;
if (e.StudentId.HasValue)
{
_bookedStudent.Add(e.StudentId.Value);
}
})
.Add <SessionSeatReleased>(e =>
{
_bookedSeats--;
_bookedStudent.Remove(e.StudentId);
});
}
public ActionResult Index()
{
if (HttpContext.User.Identity.IsAuthenticated)
{
int CurrentGame = (int)HttpContext.Profile.GetPropertyValue("CurrentGame");
if (CurrentGame > 0)
{
Guid player = (Guid)Membership.GetUser().ProviderUserKey;
EventPlayer ep = db.GetCurrentEventPlayer(CurrentGame, player);
if (ep != null)
{
//user is authenticated and in a game... go there!
return(RedirectToAction("Play", "Game"));
}
HttpContext.Profile.SetPropertyValue("CurrentGame", 0);
//User is authenticated but hasn't joined a game, so...
return(RedirectToAction("Join", "Game", new { id = DateTime.Now.Year }));
}
else
{
//User is authenticated but hasn't joined a game, so...
return(RedirectToAction("Join", "Game", new { id = DateTime.Now.Year }));
}
}
//not authenticated... show home page
return(View());
}
public void InitializeChannel(bool isTopLevel, int layer, EventPlayer player, Playlist.Channel playlistChannel, MiniTransform suppliedTransform, Performance performance)
{
this.playlistChannel = playlistChannel;
this.player = player;
//only if it has subcues
if (playlistChannel.useRandomChoice)
{
List <int> enabledIndicies = new List <int>();
for (int i = 0; i < playlistChannel.cues.Length; i++)
{
if (playlistChannel.cues[i].gameObject.activeSelf)
{
enabledIndicies.Add(i);
}
i++;
}
cueIndex = enabledIndicies.RandomChoice();
}
else
{
cueIndex = 0;
}
if (!isTopLevel)
{
if (SkipAheadPastDisabledCues(performance))
{
return;
}
}
curCueRepeats = 0;
isActive = true;
head.OnStart(isTopLevel, playlistChannel, GetCurrentCue(), GetCurrentCueBehavior(), GetCurrentPlayingEvents(), layer, player, suppliedTransform);
}
void Awake()
{
eventPlayer = GetComponent <EventPlayer>();
eventPlayer.AddParameters(new CustomParameter[] {
new CustomParameter("Agitated", false),
});
ragdollController = GetComponent <RagdollController>();
movement = GetComponent <MovementController>();
turner = GetComponent <Turner>();
//jumper = GetComponent<Jumper>();
platformer = GetComponent <Platformer>();
combat = GetComponent <CharacterCombat>();
charAnimationMover = GetComponent <CharacterAnimatorMover>();
characterMovement = GetComponent <CharacterMovement>();
turner.doAutoTurn = true;
cam = Camera.main;
combat.SetAimTargetCallback(() => cam.transform.position + cam.transform.forward * 500);
turner.SetTurnTargetCallback(() => CalculateFaceDir());
}
public void Register(PlayerCharacterEntity e)
{
if (e == null)
{
return;
}
if (teams.Count == 0)
{
return;
}
EventPlayer p = new EventPlayer {
player = e, lastPosition = e.transform.position
};
if (settings.isGlobal)
{
p.team = teams[0].info;
teams[0].players.Add(p);
}
else
{
players.Add(p);
}
}
public ActionResult Join(EventPlayer model)
{
try
{
if (ModelState.IsValid)
{
model.Event = db.GetEventByYear(model.Year);
db.AddEventPlayer(model);
HttpContext.Profile.SetPropertyValue("CurrentGame", model.Year);
var CountryList = db.GetEventCountriesByYear(model.Year);
ICollection <PlayerEventCountryScore> PECS = new List <PlayerEventCountryScore>();
foreach (var item in CountryList)
{
PECS.Add(new PlayerEventCountryScore
{
EventCountryID = item.CountryID,
PlayerGuid = model.PlayerGuid,
EventCountry = item
});
}
db.StartGameForPlayer(PECS);
return(RedirectToAction("Play", "Game"));
}
else
{
throw new Exception("Modelstate invalid");
}
}
catch (Exception ex)
{
ModelState.AddModelError("Error", ex.InnerException);
return(View(model));
}
}
void Deactivate()
{
BroadcastMessageToPlayer(layer, player, runtimeTransform, cueBehavior, Cue.MessageEvent.OnEnd);
player.cueMoving = false;
cueBehavior = null;
player = null;
isActive = false;
}
// protected override
void Awake()
{
// base.Awake();
// controller = GetComponent<MovementController>();
eventPlayer = GetComponent <EventPlayer>();
waypointTracker = GetComponent <WaypointTracker>();
}
protected override void AddPlayers(EventPlayer player)
{
base.AddPlayers(player);
player.Add <LocationAssigned>(e => _assignedSession.Add(e.SessionStart, e.Duration))
.Add <LocationReassigned>(e => _assignedSession.Update(e.OldSessionStart, e.OldDuration, e.NewSessionStart, e.NewDuration))
.Add <LocationUnassigned>(e => _assignedSession.Remove(e.SessionStart, e.Duration))
.Add <LocationDisabled>(a => _disabled = true);
}
public ActionResult DeleteConfirmed(int id)
{
EventPlayer eventPlayer = db.EventPlayers.Find(id);
db.EventPlayers.Remove(eventPlayer);
db.SaveChanges();
return(RedirectToAction("Index"));
}
protected override void AddPlayers(EventPlayer player)
{
base.AddPlayers(player);
player.Add <TrainerAssigned>(e => _assignedSession.Add(e.SessionStart, e.Duration))
.Add <TrainerReassigned>(e => _assignedSession.Update(e.OldSessionStart, e.OldDuration, e.NewSessionStart, e.NewDuration))
.Add <TrainerUnassigned>(e => _assignedSession.Remove(e.SessionStart, e.Duration))
.Add <TrainerDisabled>(e => _isDisabled = true);
}
// Update is called once per frame
void Update()
{
if (playTutorial)
{
float currTime = Time.time;
if (currTime - lastTime > tutorialSpeed)
{
lastTime = currTime;
int nextPanelIndex = currPanelIndex + 1;
if (nextPanelIndex == transform.childCount)
{
nextPanelIndex = 0;
GameObject ep = GameObject.Find("DomArray");
if (ep != null)
{
EventPlayer e = ep.GetComponent <EventPlayer>();
if (e != null)
{
e.StopCurrentEvent();
e.StopTutorialEvent();
//e.scaleArray(3f);
}
}
}
/*if (currPanelIndex == 7)
* {
* GameObject ep = GameObject.Find("DomArray");
* if (ep != null)
* {
* EventPlayer e = ep.GetComponent<EventPlayer>();
* if (e != null)
* {
* e.scaleArray(0.149815f);
* }
* }
* }*/
transform.GetChild(currPanelIndex).gameObject.SetActive(false);
ActivatePanelObject apo = transform.GetChild(currPanelIndex).gameObject.GetComponent <ActivatePanelObject>();
if (apo != null)
{
if (apo.deactivateOnSwitch)
{
apo.DeactivateObject();
}
}
transform.GetChild(nextPanelIndex).gameObject.SetActive(true);
apo = transform.GetChild(nextPanelIndex).gameObject.GetComponent <ActivatePanelObject>();
if (apo != null)
{
apo.ActivateObject();
}
currPanelIndex = nextPanelIndex;
}
}
}
public void CreateSubscriptionTypesTest()
{
//create default endpoint
DXEndpoint.Create();
//try to create subscription with invalid event types parameters
//all attempts to create subscription in this block must be failed with exception
Assert.Catch(typeof(ArgumentException), () =>
{
DXFeed.GetInstance().CreateSubscription <IDxOrder>(typeof(IDxCandle), typeof(IDxQuote));
});
Assert.Catch(typeof(ArgumentException), () =>
{
DXFeed.GetInstance().CreateSubscription <IDxIndexedEvent>(typeof(IDxCandle), typeof(IDxQuote));
});
Assert.Catch(typeof(ArgumentException), () =>
{
DXFeed.GetInstance().CreateSubscription <IDxLastingEvent>(typeof(IDxOrder), typeof(IDxQuote));
});
Assert.Catch(typeof(ArgumentException), () =>
{
DXFeed.GetInstance().CreateSubscription <IDxMarketEvent>(typeof(IDxCandle));
});
Assert.Catch(typeof(ArgumentException), () =>
{
DXFeed.GetInstance().CreateSubscription <IDxMarketEvent>(typeof(string));
});
var symbol = "SYMA";
var s = DXFeed.GetInstance().CreateSubscription <IDxEventType>(typeof(IDxOrder), typeof(IDxTrade));
s.AddSymbols(symbol);
TestListener eventListener = new TestListener();
s.AddEventListener(eventListener);
EventPlayer <IDxEventType> eventPlayer = new EventPlayer <IDxEventType>(s as DXFeedSubscription <IDxEventType>);
var playedOrder = new PlayedOrder(symbol, 0, 0x4e54560000000006, 0, 0, 0, 0, 100, 25, Scope.Order, Side.Buy, 'A', OrderSource.NTV, "AAAA");
eventPlayer.PlayEvents(symbol, playedOrder);
var playedTrade = new PlayedTrade(symbol, 0, 0, 0, 'B', 123.456, 100, 123, 1.1, 0, 2.2, 0.0, Direction.Undefined, false, Scope.Regional);
eventPlayer.PlayEvents(symbol, playedTrade);
Assert.AreEqual(eventListener.GetEventCount <IDxOrder>(symbol), 1);
Assert.AreEqual(eventListener.GetEventCount <IDxTrade>(symbol), 1);
//thread-safety case
DXEndpoint.Create();
Parallel.For(ParallelFrom, ParallelTo, i =>
{
Assert.DoesNotThrow(() =>
{
DXFeed.GetInstance().CreateSubscription <IDxEventType>(typeof(IDxOrder), typeof(IDxTrade));
});
});
}
void Awake()
{
player = GetComponent <EventPlayer>();
player.AddParameter(new CustomParameter("DamageAngle", 0.0f));
player.AddParameter(new CustomParameter("Severity", 0));
// player.AddParameter(new CustomParameter("ToRight", false));
player.AddParameter(new CustomParameter("Health", 0.0f));
}
void Awake()
{
eventPlayer = GetComponent <EventPlayer>();
eventPlayer.AddParameter(new CustomParameter("Agitated", () => agitated));
movementController = GetComponent <MovementController>();
movementController.AddChangeLoopStateValueCheck(() => agitated, "agitated");
}
public void Update(double deltaTime)
{
var isPlayingEvent = _eventPlayer != null && _isEventPause == false;
_camera.IsEventMode = isPlayingEvent;
_isEventPause = _input.Pressed.R2;
_isFreeCam = _input.Pressed.L2;
if (isPlayingEvent)
{
_eventPlayer.Update(deltaTime);
if (_eventPlayer.IsEnd)
{
FadeFromBlack(1);
_eventPlayer = null;
}
}
IEntity playerEntity = null;
foreach (var entity in _actors.Where(x => x.IsMeshLoaded && x.IsVisible))
{
if (!isPlayingEvent && !_kernel.DebugMode && entity.IsPlayer)
{
playerEntity = entity;
PlayerManager.ProcessPlayer(_input, entity, _targetCamera.YRotation, deltaTime);
}
entity.Update((float)deltaTime);
}
if (!isPlayingEvent && !_kernel.DebugMode && playerEntity != null)
{
const float RadiusSpeed = 480f;
const double YSpeed = Math.PI;
var analogY = 0f;
var radius = 0f;
var yRotation = 0f;
analogY = -_input.AxisRight.X;
radius -= (float)(_input.AxisRight.Y * RadiusSpeed * deltaTime);
yRotation -= (float)(YSpeed * analogY * deltaTime);
_targetCamera.Radius = Math.Min(
Math.Max(_targetCamera.Radius + radius, _targetCamera.ObjectiveRadiusMin),
_targetCamera.ObjectiveRadiusMax);
_targetCamera.BackYRotation += yRotation;
_targetCamera.Update(playerEntity, deltaTime, Math.Abs(analogY) >= 0.9f);
}
if (_isFading)
{
UpdateFade(deltaTime);
}
}
public void DestroyEvent()
{
Completeness = 0;
if (EventController.ActiveEvents.ContainsKey(Id))
{
EventPlayer.RemoveAmbience(EventController.ActiveEvents[Id]);
EventController.ActiveEvents.Remove(Id);
}
}
public Form1()
{
InitializeComponent();
events = new List <KeyValuePair <EventArgs, EventDetails> >();
lowLevelMouseListener = new LowLevelMouseListener(events);
lowLevelKeyboardListener = new LowLevelKeyboardListener(events);
eventPlayer = new EventPlayer();
btnPlay.Enabled = false;
btnStop.Enabled = false;
}
int?SourceRepository.GetUserPredictionForYear(int id, Guid guid)
{
EventPlayer ep = db.EventPlayers.Where(x => x.PlayerGuid == guid && x.Year == id).FirstOrDefault();
if (ep != null)
{
return(ep.PredictedUKScore);
}
return(null);
}
void SaveHomeLocation(BasePlayer player)
{
EventPlayer eventplayer = player.GetComponent <EventPlayer>();
if (eventplayer == null)
{
return;
}
eventplayer.SaveHome();
}
public void apply_method_for_one_event()
{
var raised = false;
var player = new EventPlayer();
player.Add <TestEvent1>(a => { raised = true; });
player.Apply(new TestEvent1());
raised.Should().BeTrue();
}
public void dont_raise_event_for_unregistered_event()
{
var raised1 = false;
var player = new EventPlayer();
player.Add <TestEvent1>(a => { raised1 = true; });
player.Apply(new TestEvent2());
raised1.Should().BeFalse();
}
public void PlayEvent(string eventName)
{
_actorIds.Clear();
_subtitleData.Clear();
_binarcAreaData.ForEntry(eventName, Bar.EntryType.Event, stream =>
{
_eventPlayer = new EventPlayer(this, Event.Read(stream));
RemoveAllActors();
_eventPlayer.Initialize();
});
}
public void OnPerformanceEnd(Performance performance, bool force)
{
if (!performance.looped || force)
{
if (player)
{
player.currentPlaylists.Remove(performance);
player = null;
}
}
isActive = false;
}
public void HappyPath()
{
var connectionProvider = new AdoNetConnectionProvider("DefaultConnection");
var player = new EventPlayer(
connectionProvider,
new ToEventConverter(),
new EventPublisher(
new UpdateAvailableCategoriesOnCategoryAdded(connectionProvider),
new UpdateCategoryTreeOnCategoryAdded(connectionProvider)));
player.Play();
}
public void HappyPath()
{
var connectionProvider = new AdoNetConnectionProvider("DefaultConnection");
var player = new EventPlayer(
connectionProvider,
new ToEventConverter(),
new EventPublisher(
new UpdateAvailableCategoriesOnCategoryAdded(connectionProvider),
new UpdateCategoryTreeOnCategoryAdded(connectionProvider)));
player.Play();
}
public ActionResult Edit([Bind(Include = "ID,PlayerID,EventID")] EventPlayer eventPlayer)
{
if (ModelState.IsValid)
{
db.Entry(eventPlayer).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.EventID = new SelectList(db.Events, "ID", "EventName", eventPlayer.EventID);
ViewBag.PlayerID = new SelectList(db.Users, "ID", "FirstName", eventPlayer.PlayerID);
return(View(eventPlayer));
}
void Awake()
{
if (instance == null)
{
instance = this;
DontDestroyOnLoad(gameObject);
uniqueId = 0;
}
else
{
DestroyImmediate(gameObject);
}
}
