public override void ApplyEvent(GameWorldController gameWorldController, GameEvent.OnEventCompleteDelegate onComplete)
{
base.ApplyEvent(gameWorldController, onComplete);
EnergyTankEntity energyTankEntity = gameWorldController.Model.GetEnergyTankEntity(EnergyTankId);
energyTankEntity.Energy = (uint)Math.Max((int)energyTankEntity.Energy - EnergyDrained, 0);
if (DrainerFaction == GameConstants.eFaction.ai)
{
MobEntity mobEntity = gameWorldController.Model.GetMobEntity(DrainerId);
mobEntity.Energy = mobEntity.Energy + EnergyDrained;
}
else if (DrainerFaction == GameConstants.eFaction.player)
{
CharacterEntity characterEntity = gameWorldController.Model.GetCharacterEntity(DrainerId);
characterEntity.Energy = characterEntity.Energy + EnergyDrained;
}
// Completes immediately
if (onComplete != null)
{
onComplete();
}
}
public override void eventHappened(GameEvent ge)
{
if(ge.getParameter("Inventory") == this || ge.getParameter("Inventory") == this.Entity.gameObject)
{
Item item = (Item)ge.getParameter("Item");
switch (ge.Name.ToLower())
{
case "open inventory":
openInventory = true;
events.Add(ge);
break;
case "add item":
itemsToAdd.Add (item);
events.Add(ge);
break;
case "remove item":
itemsToRemove.Add(item);
events.Add(ge);
break;
case "use item":
itemsToUse.Add(item);
events.Add(ge);
break;
}
}
}
///////////////////////////////////////////////////////////////////////////
// EVENT LISTENING
///////////////////////////////////////////////////////////////////////////
public void eventReceived(GameEvent e)
{
if (e is PlayerActionEvent)
{
KeyCode pressedKey = (e as PlayerActionEvent).pressedKey;
switch (pressedKey){
case KeyCode.Space:
Debug.Log ("ESPAÇOOOOOOOOOOOOOOOOOOO");
break;
case KeyCode.UpArrow:
FireBullet("Up");
break;
case KeyCode.LeftArrow:
FireBullet("Left");
break;
case KeyCode.RightArrow:
FireBullet("Right");
break;
case KeyCode.DownArrow:
FireBullet("Down");
break;
default :
Debug.Log(pressedKey.GetTypeCode());
break;
}
}
}
//Out's a game event if it exists otherwise it will out null
public void GetEventFromPool(string key, out GameEvent gameEvent)
{
if (_eventDictionary.ContainsKey (key))
gameEvent = _eventDictionary [key];
else
gameEvent = null;
}
void Awake()
{
for (int i = 0; i < eventNames.Length; i++) {
GameEvent gameEvent = new GameEvent();
AddEventToPool (eventNames[i], ref gameEvent);
}
}
//Adds a game event to the collection of events if it does not exist
//or replaces the event with the Key if it does exist
public void AddEventToPool(string key, ref GameEvent gameEvent)
{
if (!_eventDictionary.ContainsKey (key))
_eventDictionary.Add (key, gameEvent);
else
_eventDictionary [key] = gameEvent;
}
private void FilterEvent(GameEvent gameEvent)
{
foreach (EventFilter filter in _filters)
{
filter.FilterEvent(gameEvent);
}
}
public void SendEvent(GameEvent gameEvent, List<IEventReceiver> receivers)
{
foreach (IEventReceiver receiver in receivers)
{
SendEvent(gameEvent, receiver);
}
}
public void SetAlertLevel(GameEvent.eEventLevel alertLevel)
{
Color orange = new Color(1f,.55f,0f);
switch (alertLevel)
{
case GameEvent.eEventLevel.Informational:
ButtonText.color = Color.white;
break;
case GameEvent.eEventLevel.Positive:
ButtonText.color = Color.green;
break;
case GameEvent.eEventLevel.Moderate:
ButtonText.color = Color.yellow;
break;
case GameEvent.eEventLevel.Serious:
ButtonText.color = orange;
break;
case GameEvent.eEventLevel.Critical:
ButtonText.color = Color.red;
break;
default:
ButtonText.color = Color.white;
break;
}
}
public ChangeSwitchEventEditor()
{
this.ge = ScriptableObject.CreateInstance<GameEvent> ();
ge.Name = this.EventName;
ge.setParameter ("switch", "");
ge.setParameter ("value", true);
}
public void HandleEvent(GameEvent ge)
{
Vector3 mousepos = InputWatcher.GetInputPosition ();
if (ge.type.Equals ("mouse_release")) {
//Stops the dial from spinning more
spinner = false;
//Only tries to lock if the spinner has a chance of moving
if(clickTime > clickDelay){
//Locks position to nearest interval of 60
float rotation = transform.eulerAngles.z;
float lockRot = Mathf.Round(rotation /90.0f)*90;
transform.rotation = Quaternion.Euler(0, 0, lockRot);
PieceController pc = EditorController.GetFloatingPiece();
if(pc != null)
pc.SetRotation(360 - transform.rotation.eulerAngles.z);
}
//resets time
clickTime = 0;
touchDown = false;
}else if(ge.type.Equals("mouse_click")){
//Allows the dial to start spinning
if(spinner == false){
float dist = Mathf.Sqrt(((mousepos.x-transform.position.x)*(mousepos.x-transform.position.x))
+((mousepos.y-transform.position.y)*(mousepos.y-transform.position.y)));
if(dist > radius)
return;
originalRot = Mathf.Atan2(mousepos.y-transform.position.y,mousepos.x-transform.position.x);
origz = transform.eulerAngles.z;
//Debug.Log ("new original degrees: " + originalRot);
}
spinner = true;
touchDown = true;
}
}
public override void ApplyEvent(GameWorldController gameWorldController, GameEvent.OnEventCompleteDelegate onComplete)
{
GameData currentGame = gameWorldController.Model.CurrentGame;
if (currentGame.CharacterID != _characterState.character_id)
{
base.ApplyEvent(gameWorldController, onComplete);
// Add the character state to the current game state
currentGame.SetCharacterById(_characterState.character_id, _characterState);
// Create a new character entity using the character data just set in the game state
{
CharacterEntity characterEntity = new CharacterEntity(_characterState.character_id);
characterEntity.AddToGameWorld(gameWorldController);
}
}
else
{
Debug.Log("Ignoring apply CharacterJoinedGame event for primary character_id=" + _characterState.character_id);
}
// Completes immediately
if (onComplete != null)
{
onComplete();
}
}
public void Notify(GameObject aEntity, GameEvent aEvent) // Entity responsible for the event and the event that occured
{
for (int i = 0; i < m_NumObservers; i++)
{
m_ObserverList[i].OnNotify(ref aEntity, aEvent);
}
}
//bool decisionMade;
public void AssignEvent(GameEvent newEvent, MapRegion eventRegion, List<PartyMember> movedMembers)
{
GameEventManager.mainEventManager.drawingEvent=true;
currentTeamRegion=eventRegion;
teamList=movedMembers;
assignedEvent=newEvent;
descriptionText.text=newEvent.GetDescription(currentTeamRegion,teamList);
//decisionMade=false;
List<EventChoice> choices=newEvent.GetChoices(currentTeamRegion,teamList);
if (choices!=null)
{
foreach (EventChoice choice in choices)
{
Button newButton=Instantiate(decisionButtonPrefab);
newButton.transform.SetParent(transform.FindChild("Event Panel").FindChild("Decision Group"),false);
//this is required, otherwise lambda listener only captures the last choice iteration
newButton.GetComponentInChildren<Text>().text=choice.choiceTxt;
newButton.interactable=!choice.grayedOut;
newButton.onClick.AddListener(()=>ResolveChoice(newButton.GetComponentInChildren<Text>().text));
}
}
else
{
//Create exit button
Button newButton=Instantiate(decisionButtonPrefab);
newButton.transform.SetParent(transform.FindChild("Event Panel").FindChild("Decision Group"),false);
newButton.GetComponentInChildren<Text>().text="Close";
newButton.onClick.AddListener(CloseChoiceScreen);
}
}
public void HandleEvent(GameEvent ge)
{
if(ge.type.Equals("enemy_finished") || ge.type.Equals("boss_hit")){
string key = (string)ge.args [0];
float damage = (float)ge.args[1];
if (ge.type.Equals("boss_hit")) {
key = "BOSSLOG" + key; //bosses don't have filenames, so mark this entry as special
}
if(enemyDamages.ContainsKey(key)){ //if this is an enemy type that's already hit
float newdmg = damage + enemyDamages[key]; //add new damage to old damage
enemyDamages[key] = newdmg; //update
}else{ //a new enemy type
enemyDamages.Add(key,damage); //make new entry
}
}else if(ge.type.Equals("piece_obtained")){
string key = (string)ge.args[0];
if(pieceCounts.ContainsKey(key)){
pieceCounts[key]++;
}else{
pieceCounts.Add(key,1);
}
}else if(ge.type.Equals("game_over")){
GameOver();
}else if (ge.type.Equals("you_won")) {
YouWon();
}
}
private void ClimbOverEdgeMove(GameEvent gEvent)
{
if(charState.IsClimbing() && gEvent == GameEvent.ClimbOverEdge && !noClimbOver)
{
// LeanTweenPath path = new LeanTweenPath();
// LeanTweenVisual tween = new LeanTweenVisual();
////
if (charState.IsVineClimbing())
{
// tween = vineTween;
// path = vinePath;
// print("ClimbOverVine: should start climbing over vine");
}
else if(charState.IsEdgeClimbing())
{
// tween = edgeTween;
// path = edgePath;
}
//EnableClimbOverTween(path, tween, true);
//path.transform.parent = null;
animator.SetTrigger("ClimbOverEdge");
RSUtil.Instance.DelayedAction(() => {
//path.transform.parent = transform;
//path.transform.localPosition = Vector3.zero;
//EnableClimbOverTween(path, tween, false);
EventManager.OnCharEvent(GameEvent.FinishClimbOver);
noClimbOver = false;
}, tweenDuration);
}
}
///////////////////////////////////////////////////////////////////////////
// EVENT LISTENING
///////////////////////////////////////////////////////////////////////////
public void eventReceived(GameEvent e)
{
if (e is PlayerFireEvent) {
Debug.Log ("send fireProjectile");
GetComponent<MonkController>().fireProjectile();
}
}
public AddItemEditor()
{
this.ge = ScriptableObject.CreateInstance<GameEvent> ();
ge.Name = this.EventName;
ge.setParameter ("item", null);
ge.setParameter ("inventory", null);
}
public void HandleEvent(GameEvent ge)
{
if(Pause.paused)
return;
Vector3 mousepos = InputWatcher.GetCanvasInputPosition((RectTransform)canvas.transform);
if(ge.type.Equals("mouse_click")){
if(spinning)
return;
spinning = true;
startingDialRot = transform.eulerAngles.z * Mathf.Deg2Rad;
startingMouseRot = Mathf.Atan2(mousepos.y-anchorY,mousepos.x-anchorX);
}else if(ge.type.Equals("mouse_release")){
if(!spinning)
return;
spinning = false;
float mouseAngle = Mathf.Atan2 ((mousepos.y - anchorY) - transform.position.y, (mousepos.x-anchorX) - transform.position.x);
float angleChange = mouseAngle-startingMouseRot;
transform.eulerAngles = new Vector3(transform.eulerAngles.x,transform.eulerAngles.y,(startingDialRot + angleChange)*Mathf.Rad2Deg);
float rotation = transform.eulerAngles.z;
float lockRot = Mathf.Round (rotation / 60) * 60;
UpdateSelection(lockRot);
transform.rotation = Quaternion.Euler (0, 0, lockRot);
}
}
///////////////////////////////////////////////////////////////////////////
// EVENT LISTENING
//////////////////////////////////////////////////////////////////////////
public void eventReceived(GameEvent e)
{
if (e is NPCHealthEvent) {
NPCHealthEvent evento = (e as NPCHealthEvent);
///////////////////////////////////////
/// Confere se foi o monstro alvo
var selfID = gameObject.GetInstanceID();
if (selfID == evento.NPCInstanceID){
NPCHealthChange = evento.NPCHealth;
if ((NPCHealthLvl >= NPCMaxHealth / 2) && (NPCHealthLvl+NPCHealthChange < NPCMaxHealth / 2))
GameEventManager.post(new NPCStateEvent(selfID, 2)); //dispara o evento de transformação do inimigo em Vegetal. Esse evento será disparado com o efeito do antidoto
if ((NPCHealthLvl < NPCMaxHealth / 2) && (NPCHealthLvl + NPCHealthChange >= NPCMaxHealth / 2))
GameEventManager.post(new NPCStateEvent(selfID, 1)); //dispara o evento de transformação do vegetal em Inimigo. Esse evento será disparado pelo efeito do veneno no ataque dos inimigos no vegetal, que poderá transformar-lo novamente em vegetalInimigo
NPCHealthLvl += NPCHealthChange;
if (NPCHealthLvl <= 0){
Die ();
NPCHealthLvl = 0;
}
///////////////////////////////////////////////////////////////////
/// Exibe Dano
var selfTransform = GetComponent<Transform> ();
DamagePopUp.ShowMessage (NPCHealthChange.ToString(), selfTransform.position);
}
}
}
public override void Execute(GameEvent gameEvent)
{
bool finished = false;
GameObject actor = null;
if(this.show3)
{
actor = (GameObject)gameEvent.spawnedPrefabs[this.actorID];
}
else
{
actor = gameEvent.actor[this.actorID].GetActor();
}
if(actor != null && gameEvent.waypoint[this.waypointID] != null)
{
ActorEventMover comp = (ActorEventMover)actor.gameObject.GetComponent("ActorEventMover");
if(comp == null)
{
comp = (ActorEventMover)actor.gameObject.AddComponent("ActorEventMover");
}
comp.StartCoroutine(comp.RotateToObject(actor.transform, gameEvent.waypoint[this.waypointID], this.interpolate, this.time));
if(this.wait)
{
finished = true;
gameEvent.StartTime(this.time, this.next);
}
}
if(!finished)
{
gameEvent.StepFinished(this.next);
}
}
// Initial cost for employees is one weeks pay
public void NewEvent(int EventIndex)
{
GameEvent NewEvent = new GameEvent ();
NewEvent.EventIndex = EventIndex;
switch (EventIndex) {
case (0): // patients give money
NewEvent.EventText = "Application: Patient" + "\n" +
"Name: Steve" + "\n" +
"Income: $300" + "\n" +
"Condition: Alchoholism";
NewEvent.CashBonus = 300;
break;
case (1): // guards cost money
NewEvent.EventText = "Application: Guard" + "\n" +
"Name: Dezlo" + "\n" +
"Cost: $1050" + "\n" +
"Salary: $150 Per Day";
NewEvent.CashBonus = -1050;
break;
case (2): // doctors cost money
NewEvent.EventText = "Application: Doctor" + "\n" +
"Name: Leviathan" + "\n" +
"Cost: $2100" + "\n" +
"Salary: $300 Per Day";
NewEvent.CashBonus = -2100;
break;
}
MyEvents.Add (NewEvent);
}
private GameEvent parseEvent(GameEvent ge)
{
foreach (string contenido_param in ge.Params) {
object param = ge.getParameter(contenido_param);
if (contenido_param.Equals("direction")) {
Mover.Direction t = new Mover.Direction();
switch ((System.String)param) {
case "North": ge.setParameter(contenido_param, t); break;
case "East": ge.setParameter(contenido_param, t + 1); break;
case "South": ge.setParameter(contenido_param, t + 2); break;
case "West": ge.setParameter(contenido_param, t + 3); break;
}
} else {
if (param.GetType() == typeof(System.Int32)) {
int intParam = (int)param;
if (EntityMap.getInstance().getEntityMap().ContainsKey(intParam)) {
UnityEngine.Object go_src;
EntityMap.getInstance().getEntityMap().TryGetValue(intParam, out go_src);
ge.setParameter(contenido_param, go_src);
}
}/* else {
Debug.Log("====================================");
Debug.Log("tipo: " + param.GetType() + ", valor: " + param);
Debug.Log("====================================");
}*/
}
}
return ge;
}
public override void Execute(GameEvent gameEvent)
{
bool finished = false;
GameObject actor = null;
if(this.show3)
{
actor = (GameObject)gameEvent.spawnedPrefabs[this.actorID];
}
else
{
actor = gameEvent.actor[this.actorID].GetActor();
}
if(actor != null)
{
ActorEventMover comp = actor.gameObject.GetComponent<ActorEventMover>();
if(comp == null)
{
comp = actor.gameObject.AddComponent<ActorEventMover>();
}
Vector3 target = this.v3;
if(this.show2) target = actor.transform.TransformDirection(target);
comp.StartCoroutine(comp.MoveToDirection(actor.transform, this.controller, target, this.show, this.speed, this.time));
if(this.wait)
{
finished = true;
gameEvent.StartTime(this.time, this.next);
}
}
if(!finished)
{
gameEvent.StepFinished(this.next);
}
}
public void HandleEvent(GameEvent ge)
{
Vector3 mousepos = InputWatcher.GetInputPosition ();
mousepos = new Vector3(mousepos.x - spinPivot.transform.position.x,mousepos.y-spinPivot.transform.position.y,mousepos.z);
if (ge.type.Equals ("mouse_release")) {
//Stops the dial from spinning more
spinner = false;
//Only tries to lock if the spinner has a chance of moving
if(clickTime > clickDelay){
//Locks position to nearest interval of 60
float rotation = transform.eulerAngles.z;
float lockRot = Mathf.Round(rotation /lockThreshold)*lockThreshold;
transform.rotation = Quaternion.Euler(0, 0, lockRot);
menuPosition = (int) lockRot/lockThreshold;
if(Child.GetComponent<MenuClickScript>() != null){
Child.GetComponent<MenuClickScript>().menuPosition = menuPosition % menuMax;
}
/*if(Child.GetComponent<MenuInGame>() != null){
Child.GetComponent<MenuInGame>().menuPosition = (menuPosition % menuMax) % 4;
}*/
}
//resets time
clickTime = 0;
touchDown = false;
}else if(ge.type.Equals("mouse_click")){
//Allows the dial to start spinning
if(spinner == false){
originalRot = Mathf.Atan2(mousepos.y,mousepos.x);
origz = transform.eulerAngles.z;
//Debug.Log ("new original degrees: " + originalRot);
}
spinner = true;
touchDown = true;
}
}
public void HandleEvent(GameEvent ge)
{
if (ge.type.Equals ("mouse_release")) {
if(returnButton == null || anchorPoints == null || tintBox == null)
return;
RaycastHit targetFind;
Ray targetSeek = Camera.main.ScreenPointToRay (InputWatcher.GetTouchPosition ());
if (Physics.Raycast (targetSeek, out targetFind)) {
//sees if ray collided with the start button
if (targetFind.collider.gameObject == this.gameObject) {
if(!paused){
//moves buttons to set locations, and darkens screen
this.gameObject.transform.position = anchorPoints[0].gameObject.transform.position;
returnButton.transform.position = anchorPoints[2].gameObject.transform.position;
GetComponentInChildren<TextMesh>().text = "Resume";
tintBox.GetComponent<Renderer> ().material.color = new Color (0.0f, 0.0f, 0.0f, 0.5f);
}else{
//moves buttons back, sets screen back to normal color
this.gameObject.transform.position = anchorPoints[1].gameObject.transform.position;
returnButton.transform.position = anchorPoints[3].gameObject.transform.position;
GetComponentInChildren<TextMesh>().text = "Pause";
tintBox.GetComponent<Renderer> ().material.color = new Color (0.0f, 0.0f, 0.0f, 0.0f);
}
paused = !paused;
}
}
}
}
public void HandleEvent(GameEvent ge)
{
if (ge.type.Equals ("mouse_release")) {
RaycastHit targetFind;
Ray targetSeek = Camera.main.ScreenPointToRay (InputWatcher.GetTouchPosition ());
if (Physics.Raycast (targetSeek, out targetFind)) {
Debug.Log (targetFind.collider.name);
//sees if ray collided with the start button
if (targetFind.collider.gameObject == startButton) {
//Debug.Log ("try and load level select");
if(levelHolder[menuPosition] == "Return"){
Camera.main.transform.position = cameraLock2.transform.position;
}else{
WorldData.lastScene = Application.loadedLevelName;
levelName = levelHolder[menuPosition];
GamePause.paused = false;
Application.LoadLevel(levelName);
}
/*if(menuPosition == 3 || menuPosition == 1){
worldHolder.GetComponent<WorldData>().lastScene = Application.loadedLevelName;
Application.LoadLevel(levelName);
}else if(menuPosition == 2){
Camera.main.transform.position = cameraLock2.transform.position;
}*/
}
}
}
}
public void SendEvent(GameEvent gameEvent, IEventReceiver receiver)
{
SingletonFactory.LOG.Log("SendEvent: " + gameEvent.ToString() + (receiver == null ? "" : ", Receiver: " + receiver.ToString()), Logging.LoggerLevel.LOW);
SingletonFactory.LOG.Log("EventArgs: " + gameEvent.ArgString);
FilterEvent(gameEvent);
receiver.OnEvent(gameEvent);
}
///////////////////////////////////////////////////////////////////////////
// EVENT LISTENING
///////////////////////////////////////////////////////////////////////////
public void eventReceived(GameEvent e)
{
if (e is PlayerMoveEvent)
{
KeyCode k = (e as PlayerMoveEvent).pressedKey;
string strKeyPressed = k.ToString();
switch (strKeyPressed){
case "A":
Flip ("left");
anim.SetBool("Idle",false);
anim.SetBool("WalkRight",false);
anim.SetBool("WalkLeft",true);
break;
case "D":
Flip ("right");
anim.SetBool("Idle",false);
anim.SetBool("WalkRight",true);
anim.SetBool("WalkLeft",false);
break;
default:
anim.SetBool("Idle",true);
anim.SetBool("WalkRight",false);
anim.SetBool("WalkLeft",false);
break;
}
}
if (e is PlayerActionEvent) {
KeyCode k = (e as PlayerActionEvent).pressedKey;
}
}
public override void Execute(GameEvent gameEvent)
{
if(MusicPlayType.PLAY.Equals(this.playType))
{
if(this.show) GameHandler.GetMusicHandler().PlayStored();
else GameHandler.GetMusicHandler().Play(this.musicID);
}
else if(MusicPlayType.STOP.Equals(this.playType))
{
GameHandler.GetMusicHandler().Stop();
}
else if(MusicPlayType.FADE_IN.Equals(this.playType))
{
if(this.show) GameHandler.GetMusicHandler().FadeInStored(this.float1, this.interpolate);
else GameHandler.GetMusicHandler().FadeIn(this.musicID, this.float1, this.interpolate);
}
else if(MusicPlayType.FADE_OUT.Equals(this.playType))
{
GameHandler.GetMusicHandler().FadeOut(this.float1, this.interpolate);
}
else if(MusicPlayType.FADE_TO.Equals(this.playType))
{
if(this.show) GameHandler.GetMusicHandler().FadeToStored(this.float1, this.interpolate);
else GameHandler.GetMusicHandler().FadeTo(this.musicID, this.float1, this.interpolate);
}
gameEvent.StepFinished(this.next);
}
public static bool UpdateCounter0(GameEvent gameEvent)
{
gameEvent.thisEffect.Counter += 1;
return(true);
}
public static bool MurlocHeroPower(GameEvent gameEvent)
{
return(true);
}
public static GameEvent ConvertGameEvent(int i)
{
return(GameEvent.GetGameEvent(i));
}
private void onLinkAdd(GameEvent e)
{
this.dispatchEvent(
GameEvent.Create(GAME_EVENT.MAP_LINK_ADD, this, e.data)
);
}
private void onChangeMap(GameEvent e)
{
this.dispatchEvent(
GameEvent.Create(GAME_EVENT.MAP_CHANGE, this, e.data)
);
}
public void OnGameEvent(GameEvent gameEvent)
{
switch (gameEvent.type)
{
case GameEventType.WhiteInScenarioCamera:
this.ScenarioCamera.SendMessage("WhiteIn");
break;
case GameEventType.WhiteOutScenarioCamera:
this.ScenarioCamera.SendMessage("WhiteOut", gameEvent.BoolParameter);
break;
case GameEventType.TimeScaleOn:
isPlayingScenario = true;
break;
case GameEventType.TimeScaleOff:
isPlayingScenario = false;
Time.timeScale = 1;
break;
case GameEventType.ScenarioCameraOff:
this.ScenarioCamera.enabled = false;
break;
case GameEventType.ScenarioCameraOn:
this.ScenarioCamera.enabled = true;
if (ScenarioCamera.gameObject.active == false)
{
ScenarioCamera.gameObject.active = true;
}
break;
case GameEventType.PlayerCameraOn:
this.PlayerCamera.enabled = true;
break;
case GameEventType.PlayerCameraOff:
this.PlayerCamera.enabled = false;
break;
case GameEventType.ScenarioCameraAudioListenerOn:
this.ScenarioAudioListener.enabled = true;
break;
case GameEventType.ScenarioCameraAudioListenerOff:
this.ScenarioAudioListener.enabled = false;
break;
case GameEventType.PlayerCameraAudioListenerOn:
this.PlayerAudioListener.enabled = true;
break;
case GameEventType.PlayerCameraAudioListenerOff:
this.PlayerAudioListener.enabled = false;
break;
case GameEventType.StartDocking:
ObjectDockMonoDict[gameEvent.StringParameter].Dock();
break;
case GameEventType.StartDockingOnRuntimeTarget:
ObjectDockMonoDict[gameEvent.StringParameter].Dock(gameEvent.receiver.transform);
break;
case GameEventType.PlayerCameraSlowMotionOnFixedPoint:
case GameEventType.PlayerCameraSlowMotionOnTransform:
case GameEventType.PlayerCameraSlowMotionOnPredefinedViewPointAndLookOnFixedPoint:
case GameEventType.PlayerCameraSlowMotionOnPredefinedViewPointAndLookOnTransform:
this.PlayerCamera.SendMessage("OnGameEvent", gameEvent);
break;
case GameEventType.ShiftToPlayerMode:
//to shift to Player mode:
//1. activate player
//2. deactivate scenario camera + audio listener
LevelManager.Instance.player.SetActive(true);
LevelManager.Instance.player.transform.root.gameObject.SetActive(true);
GameEvent event_player_control_on = new GameEvent(GameEventType.PlayerControlOn);
LevelManager.OnGameEvent(event_player_control_on, this);
PlayerCamera.enabled = true;
PlayerAudioListener.enabled = true;
this.ScenarioCamera.enabled = false;
this.ScenarioAudioListener.enabled = false;
break;
case GameEventType.ShiftToScenarioMode:
//to shift to scenario mode:
//1. if BOOL parameter = false, de-activate player , else , deactivate player control and camera+audio
//2. deactivate scenario camera + audio listener
if (gameEvent.BoolParameter == true)
{
//let player visible in camera.
this.PlayerCamera.enabled = false;
this.PlayerAudioListener.enabled = false;
GameEvent event_player_control_off = new GameEvent(GameEventType.PlayerControlOff);
LevelManager.OnGameEvent(event_player_control_off, this);
}
else
{
LevelManager.Instance.player.transform.root.gameObject.SetActive(false);
}
this.ScenarioCamera.enabled = true;
this.ScenarioAudioListener.enabled = true;
break;
}
}
public void Propagate(GameEvent gameEvent)
{
}
public DefaultEventEditor()
{
this.ge = ScriptableObject.CreateInstance <GameEvent> ();
}
public void detachEvent(GameEvent ge)
{
}
private void OnDisable()
{
gameEvent -= this;
}
private void OnEnable()
{
gameEvent += this;
}
void GetInfo(GameEvent e)
{
Variant data = e.data;
name = data["name"];
carr = data["carr"];
lvl = data["lvl"];
zhuan = data["zhuan"];
combpt = data["combpt"];
wing_lvl = data["wing_lvl"];
if (data.ContainsKey("wing_stage"))
{
wing_stage = data["wing_stage"];
}
if (data.ContainsKey("show_wing"))
{
show_wing = data["show_wing"];
}
if (data.ContainsKey("pet_type"))
{
pet_type = data["pet_type"];
}
if (data.ContainsKey("clan_name"))
{
clan_name = data["clan_name"];
}
if (data.ContainsKey("summon_combpt"))
{
summon_combpt = data["summon_combpt"];
}
if (data.ContainsKey("grade"))
{
jjclvl = data["grade"];
}
if (data.ContainsKey("score"))
{
jjcfec = data["score"];
}
if (data.ContainsKey("dress_list"))
{
if (data["dress_list"] != null && data["dress_list"].Count > 0)
{
fashionsshows[0] = data["dress_list"][0]._int;
fashionsshows[1] = data["dress_list"][1]._int;
}
else
{
fashionsshows[0] = fashionsshows[1] = 0;
}
}
else
{
clan_name = "";
}
string file = "";
switch (carr)
{
case 1:
break;
case 2:
file = "icon_job_icon_h2";
break;
case 3:
file = "icon_job_icon_h3";
break;
case 4:
file = "icon_job_icon_h4";
break;
case 5:
file = "icon_job_icon_h5";
break;
}
Image head = transform.FindChild("playerInfo/panel_attr/hero_ig/ig").GetComponent <Image>();
head.sprite = GAMEAPI.ABUI_LoadSprite(file);
transform.FindChild("playerInfo/panel_attr/name").GetComponent <Text>().text = name;
transform.FindChild("playerInfo/panel_attr/lv").GetComponent <Text>().text = "Lv" + lvl + "（" + zhuan + ContMgr.getCont("zhuan") + "）";
getTransformByPath("fighting/value").GetComponent <Text>().text = combpt.ToString();
if (jjclvl > 0)
{
SXML itXml = XMLMgr.instance.GetSXML("jjc.reward", "grade==" + jjclvl);
string jjc = itXml.getString("name");
transform.FindChild("playerInfo/panel_attr/attr_scroll/scroll/contain/1/value").GetComponent <Text>().text = jjc;
}
else
{
transform.FindChild("playerInfo/panel_attr/attr_scroll/scroll/contain/1/value").GetComponent <Text>().text = ContMgr.getCont("a3_targetinfo_nodw");
}
if (jjclvl < 10)
{
transform.FindChild("playerInfo/panel_attr/attr_scroll/scroll/contain/1/icon").GetComponent <Image>().sprite = GAMEAPI.ABUI_LoadSprite("icon_rank_00" + jjclvl);
}
else
{
transform.FindChild("playerInfo/panel_attr/attr_scroll/scroll/contain/1/icon").GetComponent <Image>().sprite = GAMEAPI.ABUI_LoadSprite("icon_rank_0" + jjclvl);
}
transform.FindChild("playerInfo/panel_attr/attr_scroll/scroll/contain/2/value").GetComponent <Text>().text = summon_combpt.ToString();
transform.FindChild("playerInfo/panel_attr/attr_scroll/scroll/contain/3/value").GetComponent <Text>().text = wing_stage + ContMgr.getCont("a3_auction_jie") + wing_lvl + ContMgr.getCont("ji");
if (data.ContainsKey("min_attack"))
{
transform.FindChild("playerInfo/panel_attr/att/atk/value").GetComponent <Text>().text = data["min_attack"] + "-" + data["max_attack"];
transform.FindChild("playerInfo/panel_attr/att/hp/value").GetComponent <Text>().text = data["max_hp"];
transform.FindChild("playerInfo/panel_attr/att/phydef/value").GetComponent <Text>().text = data["physics_def"];
transform.FindChild("playerInfo/panel_attr/att/manadef/value").GetComponent <Text>().text = data["magic_def"];
}
if (clan_name == "")
{
transform.FindChild("playerInfo/panel_attr/team").gameObject.SetActive(false);
transform.FindChild("playerInfo/panel_attr/no_team").gameObject.SetActive(true);
}
else
{
transform.FindChild("playerInfo/panel_attr/team").gameObject.SetActive(true);
transform.FindChild("playerInfo/panel_attr/team/team_name").GetComponent <Text>().text = clan_name;
transform.FindChild("playerInfo/panel_attr/no_team").gameObject.SetActive(false);
}
Variant equips = data["equipments"];
Equips.Clear();
active_eqp.Clear();
foreach (var v in equips._arr)
{
a3_BagItemData item = new a3_BagItemData();
item.confdata.equip_type = v["part_id"];
Variant info = v["eqpinfo"];
item.id = info["id"];
item.tpid = info["tpid"];
item.confdata = a3_BagModel.getInstance().getItemDataById(item.tpid);
a3_EquipModel.getInstance().equipData_read(item, info);
Equips[item.confdata.equip_type] = item;
}
foreach (a3_BagItemData item in Equips.Values)
{
if (isactive_eqp(item))
{
active_eqp[item.confdata.equip_type] = item;
}
}
//Dictionary < int, a3_BagItemData > newEquip = new Dictionary<int, a3_BagItemData>();
//foreach (int itemid in Equips.Keys)
//{
// a3_BagItemData one = Equips[itemid];
// one.equipdata.combpt = a3_BagModel.getInstance().Getcombpt(a3_BagModel .getInstance ().Getequip_att(Equips[itemid]));
// newEquip[itemid] = one;
//}
//Equips.Clear();
//Equips = newEquip;
initEquipIcon();
createAvatar();
setAni();
SetAni_Color();
}
public abstract void OnEvent(GameEvent gameEvent);
public static string ClassToJson(GameEvent gameEvent)
{
return(JsonConvert.SerializeObject(gameEvent));
}
override public async Task <bool> ProcessUpdatesAsync(CancellationToken cts)
{
try
{
#region SHUTDOWN
if (Manager.ShutdownRequested())
{
foreach (var client in GetClientsAsList())
{
var e = new GameEvent()
{
Type = GameEvent.EventType.PreDisconnect,
Origin = client,
Owner = this,
};
Manager.GetEventHandler().AddEvent(e);
await e.WaitAsync();
}
foreach (var plugin in SharedLibraryCore.Plugins.PluginImporter.ActivePlugins)
{
await plugin.OnUnloadAsync();
}
return(true);
}
#endregion
try
{
var polledClients = await PollPlayersAsync();
var waiterList = new List <GameEvent>();
foreach (var disconnectingClient in polledClients[1])
{
if (disconnectingClient.State == ClientState.Disconnecting)
{
continue;
}
var e = new GameEvent()
{
Type = GameEvent.EventType.PreDisconnect,
Origin = disconnectingClient,
Owner = this
};
Manager.GetEventHandler().AddEvent(e);
// wait until the disconnect event is complete
// because we don't want to try to fill up a slot that's not empty yet
waiterList.Add(e);
}
// wait for all the disconnect tasks to finish
await Task.WhenAll(waiterList.Select(e => e.WaitAsync(10 * 1000)));
waiterList.Clear();
// this are our new connecting clients
foreach (var client in polledClients[0])
{
// note: this prevents players in ZMBI state from being registered with no name
if (string.IsNullOrEmpty(client.Name))
{
continue;
}
var e = new GameEvent()
{
Type = GameEvent.EventType.PreConnect,
Origin = client,
Owner = this
};
Manager.GetEventHandler().AddEvent(e);
waiterList.Add(e);
}
// wait for all the connect tasks to finish
await Task.WhenAll(waiterList.Select(e => e.WaitAsync(10 * 1000)));
waiterList.Clear();
// these are the clients that have updated
foreach (var client in polledClients[2])
{
var e = new GameEvent()
{
Type = GameEvent.EventType.Update,
Origin = client,
Owner = this
};
Manager.GetEventHandler().AddEvent(e);
waiterList.Add(e);
}
await Task.WhenAll(waiterList.Select(e => e.WaitAsync(10 * 1000)));
if (ConnectionErrors > 0)
{
var _event = new GameEvent()
{
Type = GameEvent.EventType.ConnectionRestored,
Owner = this,
Origin = Utilities.IW4MAdminClient(this),
Target = Utilities.IW4MAdminClient(this)
};
Manager.GetEventHandler().AddEvent(_event);
}
ConnectionErrors = 0;
LastPoll = DateTime.Now;
}
catch (NetworkException e)
{
ConnectionErrors++;
if (ConnectionErrors == 3)
{
var _event = new GameEvent()
{
Type = GameEvent.EventType.ConnectionLost,
Owner = this,
Origin = Utilities.IW4MAdminClient(this),
Target = Utilities.IW4MAdminClient(this),
Extra = e,
Data = ConnectionErrors.ToString()
};
Manager.GetEventHandler().AddEvent(_event);
}
return(true);
}
LastMessage = DateTime.Now - start;
lastCount = DateTime.Now;
// update the player history
if ((lastCount - playerCountStart).TotalMinutes >= SharedLibraryCore.Helpers.PlayerHistory.UpdateInterval)
{
while (ClientHistory.Count > ((60 / SharedLibraryCore.Helpers.PlayerHistory.UpdateInterval) * 12)) // 12 times a hour for 12 hours
{
ClientHistory.Dequeue();
}
ClientHistory.Enqueue(new SharedLibraryCore.Helpers.PlayerHistory(ClientNum));
playerCountStart = DateTime.Now;
}
// send out broadcast messages
if (LastMessage.TotalSeconds > Manager.GetApplicationSettings().Configuration().AutoMessagePeriod &&
BroadcastMessages.Count > 0 &&
ClientNum > 0)
{
string[] messages = (await this.ProcessMessageToken(Manager.GetMessageTokens(), BroadcastMessages[NextMessage])).Split(Environment.NewLine);
foreach (string message in messages)
{
Broadcast(message);
}
NextMessage = NextMessage == (BroadcastMessages.Count - 1) ? 0 : NextMessage + 1;
start = DateTime.Now;
}
return(true);
}
// this one is ok
catch (ServerException e)
{
if (e is NetworkException && !Throttled)
{
Logger.WriteError(loc["SERVER_ERROR_COMMUNICATION"].FormatExt($"{IP}:{Port}"));
Logger.WriteDebug(e.GetExceptionInfo());
}
return(false);
}
catch (Exception E)
{
Logger.WriteError(loc["SERVER_ERROR_EXCEPTION"].FormatExt($"[{IP}:{Port}]"));
Logger.WriteDebug(E.GetExceptionInfo());
return(false);
}
}
protected override void _onProcess()
{
(this.session as ClientSession).g_mgr.dispatchEvent(GameEvent.Create(37u, this, this.msgData, false));
}
/**地图大小*/
void OnMapSize(GameEvent evt)
{
m_cameraArea = evt.Get <Bounds>(0);
}
/// <summary>
/// Perform the server specific tasks when an event occurs
/// </summary>
/// <param name="E"></param>
/// <returns></returns>
override protected async Task <bool> ProcessEvent(GameEvent E)
{
if (E.Type == GameEvent.EventType.ConnectionLost)
{
var exception = E.Extra as Exception;
Logger.WriteError(exception.Message);
if (exception.Data["internal_exception"] != null)
{
Logger.WriteDebug($"Internal Exception: {exception.Data["internal_exception"]}");
}
Logger.WriteInfo("Connection lost to server, so we are throttling the poll rate");
Throttled = true;
}
if (E.Type == GameEvent.EventType.ConnectionRestored)
{
if (Throttled)
{
Logger.WriteVerbose(loc["MANAGER_CONNECTION_REST"].FormatExt($"[{IP}:{Port}]"));
}
Logger.WriteInfo("Connection restored to server, so we are no longer throttling the poll rate");
Throttled = false;
}
if (E.Type == GameEvent.EventType.ChangePermission)
{
var newPermission = (Permission)E.Extra;
if (newPermission < Permission.Moderator)
{
// remove banned or demoted privileged user
Manager.GetPrivilegedClients().Remove(E.Target.ClientId);
}
else
{
if (Manager.GetPrivilegedClients().ContainsKey(E.Target.ClientId))
{
Manager.GetPrivilegedClients()[E.Target.ClientId] = E.Target;
}
else
{
Manager.GetPrivilegedClients().Add(E.Target.ClientId, E.Target);
}
}
Logger.WriteInfo($"{E.Origin} is setting {E.Target} to permission level {newPermission}");
await Manager.GetClientService().UpdateLevel(newPermission, E.Target, E.Origin);
}
else if (E.Type == GameEvent.EventType.PreConnect)
{
// we don't want to track bots in the database at all if ignore bots is requested
if (E.Origin.IsBot && Manager.GetApplicationSettings().Configuration().IgnoreBots)
{
return(false);
}
var existingClient = GetClientsAsList().FirstOrDefault(_client => _client.Equals(E.Origin));
// they're already connected
if (existingClient != null)
{
Logger.WriteWarning($"detected preconnect for {E.Origin}, but they are already connected");
return(false);
}
CONNECT:
if (Clients[E.Origin.ClientNumber] == null)
{
#if DEBUG == true
Logger.WriteDebug($"Begin PreConnect for {E.Origin}");
#endif
// we can go ahead and put them in so that they don't get re added
Clients[E.Origin.ClientNumber] = E.Origin;
await OnClientConnected(E.Origin);
ChatHistory.Add(new ChatInfo()
{
Name = E.Origin.Name,
Message = "CONNECTED",
Time = DateTime.UtcNow
});
if (E.Origin.Level > EFClient.Permission.Moderator)
{
E.Origin.Tell(string.Format(loc["SERVER_REPORT_COUNT"], E.Owner.Reports.Count));
}
}
// for some reason there's still a client in the spot
else
{
Logger.WriteWarning($"{E.Origin} is connecteding but {Clients[E.Origin.ClientNumber]} is currently in that client slot");
await OnClientDisconnected(Clients[E.Origin.ClientNumber]);
goto CONNECT;
}
}
else if (E.Type == GameEvent.EventType.Flag)
{
// todo: maybe move this to a seperate function
Penalty newPenalty = new Penalty()
{
Type = Penalty.PenaltyType.Flag,
Expires = DateTime.UtcNow,
Offender = E.Target,
Offense = E.Data,
Punisher = E.Origin,
When = DateTime.UtcNow,
Link = E.Target.AliasLink
};
var addedPenalty = await Manager.GetPenaltyService().Create(newPenalty);
E.Target.SetLevel(Permission.Flagged, E.Origin);
}
else if (E.Type == GameEvent.EventType.Unflag)
{
var unflagPenalty = new Penalty()
{
Type = Penalty.PenaltyType.Unflag,
Expires = DateTime.UtcNow,
Offender = E.Target,
Offense = E.Data,
Punisher = E.Origin,
When = DateTime.UtcNow,
Link = E.Target.AliasLink
};
await Manager.GetPenaltyService().Create(unflagPenalty);
E.Target.SetLevel(Permission.User, E.Origin);
}
else if (E.Type == GameEvent.EventType.Report)
{
Reports.Add(new Report()
{
Origin = E.Origin,
Target = E.Target,
Reason = E.Data
});
}
else if (E.Type == GameEvent.EventType.TempBan)
{
await TempBan(E.Data, (TimeSpan)E.Extra, E.Target, E.Origin);;
}
else if (E.Type == GameEvent.EventType.Ban)
{
bool isEvade = E.Extra != null ? (bool)E.Extra : false;
await Ban(E.Data, E.Target, E.Origin, isEvade);
}
else if (E.Type == GameEvent.EventType.Unban)
{
await Unban(E.Data, E.Target, E.Origin);
}
else if (E.Type == GameEvent.EventType.Kick)
{
await Kick(E.Data, E.Target, E.Origin);
}
else if (E.Type == GameEvent.EventType.Warn)
{
await Warn(E.Data, E.Target, E.Origin);
}
else if (E.Type == GameEvent.EventType.Disconnect)
{
ChatHistory.Add(new ChatInfo()
{
Name = E.Origin.Name,
Message = "DISCONNECTED",
Time = DateTime.UtcNow
});
await new MetaService().AddPersistentMeta("LastMapPlayed", CurrentMap.Alias, E.Origin);
await new MetaService().AddPersistentMeta("LastServerPlayed", E.Owner.Hostname, E.Origin);
}
else if (E.Type == GameEvent.EventType.PreDisconnect)
{
// predisconnect comes from minimal rcon polled players and minimal log players
// so we need to disconnect the "full" version of the client
var client = GetClientsAsList().FirstOrDefault(_client => _client.Equals(E.Origin));
if (client != null)
{
#if DEBUG == true
Logger.WriteDebug($"Begin PreDisconnect for {client}");
#endif
await OnClientDisconnected(client);
#if DEBUG == true
Logger.WriteDebug($"End PreDisconnect for {client}");
#endif
}
else if (client?.State != ClientState.Disconnecting)
{
Logger.WriteWarning($"Client {E.Origin} detected as disconnecting, but could not find them in the player list");
Logger.WriteDebug($"Expected {E.Origin} but found {GetClientsAsList().FirstOrDefault(_client => _client.ClientNumber == E.Origin.ClientNumber)}");
return(false);
}
}
else if (E.Type == GameEvent.EventType.Update)
{
#if DEBUG == true
Logger.WriteDebug($"Begin Update for {E.Origin}");
#endif
await OnClientUpdate(E.Origin);
}
if (E.Type == GameEvent.EventType.Say)
{
E.Data = E.Data.StripColors();
if (E.Data?.Length > 0)
{
string message = E.Data;
if (E.Data.IsQuickMessage())
{
try
{
message = Manager.GetApplicationSettings().Configuration()
.QuickMessages
.First(_qm => _qm.Game == GameName)
.Messages[E.Data.Substring(1)];
}
catch { }
}
ChatHistory.Add(new ChatInfo()
{
Name = E.Origin.Name,
Message = message,
Time = DateTime.UtcNow
});
}
}
if (E.Type == GameEvent.EventType.MapChange)
{
Logger.WriteInfo($"New map loaded - {ClientNum} active players");
// iw4 doesn't log the game info
if (E.Extra == null)
{
var dict = await this.GetInfoAsync();
if (dict == null)
{
Logger.WriteWarning("Map change event response doesn't have any data");
}
else
{
Gametype = dict["gametype"].StripColors();
Hostname = dict["hostname"]?.StripColors();
string mapname = dict["mapname"]?.StripColors() ?? CurrentMap.Name;
CurrentMap = Maps.Find(m => m.Name == mapname) ?? new Map()
{
Alias = mapname, Name = mapname
};
}
}
else
{
var dict = (Dictionary <string, string>)E.Extra;
Gametype = dict["g_gametype"].StripColors();
Hostname = dict["sv_hostname"].StripColors();
MaxClients = int.Parse(dict["sv_maxclients"]);
string mapname = dict["mapname"].StripColors();
CurrentMap = Maps.Find(m => m.Name == mapname) ?? new Map()
{
Alias = mapname,
Name = mapname
};
}
}
if (E.Type == GameEvent.EventType.MapEnd)
{
Logger.WriteInfo("Game ending...");
SessionStart = DateTime.UtcNow;
}
if (E.Type == GameEvent.EventType.Tell)
{
await Tell(E.Message, E.Target);
}
if (E.Type == GameEvent.EventType.Broadcast)
{
#if DEBUG == false
// this is a little ugly but I don't want to change the abstract class
if (E.Data != null)
{
await E.Owner.ExecuteCommandAsync(E.Data);
}
#endif
}
lock (ChatHistory)
{
while (ChatHistory.Count > Math.Ceiling(ClientNum / 2.0))
{
ChatHistory.RemoveAt(0);
}
}
// the last client hasn't fully disconnected yet
// so there will still be at least 1 client left
if (ClientNum < 2)
{
ChatHistory.Clear();
}
return(true);
}
/// <summary>
/// Adds an event to the future event queue
/// </summary>
/// <param name="gameEvent">The game event to add to the Queue</param>
public void AddEvent(GameEvent gameEvent)
{
this._futureEventQueue.Enqueue(gameEvent);
}
/**绑定目标*/
void OnBindTarget(GameEvent evt)
{
Log.Info("FllowTarget::OnBindTarget");
m_targetObj = evt.Get <Transform>(0);
}
//EMPTY
#region PUBLIC_METHODS
#endregion PUBLIC_METHODS
#region PRIVATE_METHODS
/// <summary>
/// Handle the Left Controller input and put them in the Events
/// </summary>
void CheckLeftControllerInput()
{
BoolVariable temp;
#region TRIGGER
temp = LeftVariablesDictionnary.Get("TriggerIsDown");
if (!temp.Value && LeftController.GetHairTriggerDown())
{
temp.SetValue(true);
_leftEvent = (GameEvent)LeftEventsDictionnary.Get("LeftTriggerDown");
_leftEvent.Raise();
}
else if (temp.Value && LeftController.GetHairTriggerUp())
{
temp.SetValue(false);
_leftEvent = (GameEvent)LeftEventsDictionnary.Get("LeftTriggerUp");
_leftEvent.Raise();
}
#endregion TRIGGER
#region TOUCHPAD
temp = LeftVariablesDictionnary.Get("ThumbIsDown");
LeftThumbOrientation.SetValue(LeftController.GetAxis());
if (LeftController.GetPressDown(SteamVR_Controller.ButtonMask.Touchpad))
{
temp.SetValue(true);
_leftEvent = (GameEvent)LeftEventsDictionnary.Get("LeftThumbDown");
_leftEvent.Raise();
}
else if (temp.Value && LeftController.GetPressUp(SteamVR_Controller.ButtonMask.Touchpad))
{
temp.SetValue(false);
_leftEvent = (GameEvent)LeftEventsDictionnary.Get("LeftThumbUp");
_leftEvent.Raise();
}
if (LeftController.GetTouchDown(SteamVR_Controller.ButtonMask.Touchpad))
{
_leftEventBool = (GameEventBool)LeftEventsDictionnary.Get("LeftThumbTouching");
_leftEventBool.Raise(true);
}
else if (LeftController.GetTouchUp(SteamVR_Controller.ButtonMask.Touchpad))
{
_leftEventBool = (GameEventBool)LeftEventsDictionnary.Get("LeftThumbTouching");
_leftEventBool.Raise(false);
}
#endregion TOUCHPAD
#region GRIP
temp = LeftVariablesDictionnary.Get("GripIsDown");
if (!temp.Value && LeftController.GetPressDown(SteamVR_Controller.ButtonMask.Grip))
{
temp.SetValue(true);
_leftEvent = (GameEvent)LeftEventsDictionnary.Get("LeftGripDown");
_leftEvent.Raise();
}
else if (temp.Value && LeftController.GetPressUp(SteamVR_Controller.ButtonMask.Grip))
{
temp.SetValue(false);
_leftEvent = (GameEvent)LeftEventsDictionnary.Get("LeftGripUp");
_leftEvent.Raise();
}
#endregion GRIP
#region MENU
temp = LeftVariablesDictionnary.Get("MenuIsDown");
if (!temp.Value && LeftController.GetPressDown(SteamVR_Controller.ButtonMask.ApplicationMenu))
{
temp.SetValue(true);
_leftEvent = (GameEvent)LeftEventsDictionnary.Get("LeftMenuDown");
_leftEvent.Raise();
}
else if (temp.Value && LeftController.GetPressUp(SteamVR_Controller.ButtonMask.ApplicationMenu))
{
temp.SetValue(false);
_leftEvent = (GameEvent)LeftEventsDictionnary.Get("LeftMenuUp");
_leftEvent.Raise();
}
#endregion MENU
}
/// <summary>
/// Jumps to a specific GameEvent
/// </summary>
/// <param name="eventOfInterest">The GameEvent to jump to</param>
public void GoTo(GameEvent eventOfInterest)
{
this.GoTo(eventOfInterest.GetOccursAt());
}
//Observer Behavior
public void OnNotify(GameEvent e)
{
Debug.Log("ActiveCombatState Notified of some event. " + e.commandString);
}
/// <summary>
/// Initializes a new instance of <see cref="GameEventHandlerBase{TEvent}"/>.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="playerRegistry">The player registry.</param>
/// <param name="chat">The chat.</param>
/// <param name="gameEvent">The game event to handle.</param>
/// <exception cref="ArgumentException">Thrown when the handler cannot handle the message.</exception>
protected GameEventHandlerBase(ILogger logger, IPlayerRegistry playerRegistry, IChat chat, GameEvent gameEvent)
{
Logger = logger;
PlayerRegistry = playerRegistry;
Chat = chat;
if (!(gameEvent is TEvent actualEvent))
{
throw new ArgumentException($"The handler {GetType()} cannot handle message of type {gameEvent?.GetType().FullName ?? "<null>"}");
}
GameEvent = actualEvent;
}
public override async Task ExecuteAsync(GameEvent E)
{
string statLine;
EFClientStatistics pStats = null;
if (E.Data.Length > 0 && E.Target == null)
{
E.Target = E.Owner.GetClientByName(E.Data).FirstOrDefault();
if (E.Target == null)
{
E.Origin.Tell(_translationLookup["PLUGINS_STATS_COMMANDS_VIEW_FAIL"]);
}
}
var serverId = StatManager.GetIdForServer(E.Owner);
var totalRankedPlayers = await Plugin.Manager.GetTotalRankedPlayers(serverId);
// getting stats for a particular client
if (E.Target != null)
{
var performanceRanking = await Plugin.Manager.GetClientOverallRanking(E.Target.ClientId, serverId);
var performanceRankingString = performanceRanking == 0
? _translationLookup["WEBFRONT_STATS_INDEX_UNRANKED"]
: $"{_translationLookup["WEBFRONT_STATS_INDEX_RANKED"]} (Color::Accent)#{performanceRanking}/{totalRankedPlayers}";
// target is currently connected so we want their cached stats if they exist
if (E.Owner.GetClientsAsList().Any(client => client.Equals(E.Target)))
{
pStats = E.Target.GetAdditionalProperty <EFClientStatistics>(StatManager.CLIENT_STATS_KEY);
}
// target is not connected so we want to look up via database
if (pStats == null)
{
await using var context = _contextFactory.CreateContext(false);
pStats = await context.Set <EFClientStatistics>()
.FirstOrDefaultAsync(c => c.ServerId == serverId && c.ClientId == E.Target.ClientId);
}
// if it's still null then they've not gotten a kill or death yet
statLine = pStats == null
? _translationLookup["PLUGINS_STATS_COMMANDS_NOTAVAILABLE"]
: _translationLookup["COMMANDS_VIEW_STATS_RESULT"].FormatExt(pStats.Kills, pStats.Deaths,
pStats.KDR, pStats.Performance, performanceRankingString);
}
// getting self stats
else
{
var performanceRanking = await Plugin.Manager.GetClientOverallRanking(E.Origin.ClientId, serverId);
var performanceRankingString = performanceRanking == 0
? _translationLookup["WEBFRONT_STATS_INDEX_UNRANKED"]
: $"{_translationLookup["WEBFRONT_STATS_INDEX_RANKED"]} (Color::Accent)#{performanceRanking}/{totalRankedPlayers}";
// check if current client is connected to the server
if (E.Owner.GetClientsAsList().Any(client => client.Equals(E.Origin)))
{
pStats = E.Origin.GetAdditionalProperty <EFClientStatistics>(StatManager.CLIENT_STATS_KEY);
}
// happens if the user has not gotten a kill/death since connecting
if (pStats == null)
{
await using var context = _contextFactory.CreateContext(false);
pStats = (await context.Set <EFClientStatistics>()
.FirstOrDefaultAsync(c => c.ServerId == serverId && c.ClientId == E.Origin.ClientId));
}
// if it's still null then they've not gotten a kill or death yet
statLine = pStats == null
? _translationLookup["PLUGINS_STATS_COMMANDS_NOTAVAILABLE"]
: _translationLookup["COMMANDS_VIEW_STATS_RESULT"].FormatExt(pStats.Kills, pStats.Deaths,
pStats.KDR, pStats.Performance, performanceRankingString);
}
if (E.Message.IsBroadcastCommand(_config.BroadcastCommandPrefix))
{
var name = E.Target == null ? E.Origin.Name : E.Target.Name;
E.Owner.Broadcast(_translationLookup["PLUGINS_STATS_COMMANDS_VIEW_SUCCESS"].FormatExt(name));
E.Owner.Broadcast(statLine);
}
else
{
if (E.Target != null)
{
E.Origin.Tell(_translationLookup["PLUGINS_STATS_COMMANDS_VIEW_SUCCESS"].FormatExt(E.Target.Name));
}
E.Origin.Tell(statLine);
}
}
private void InitGameLose()
{
GameEvent.LevelEnded("lose");
GameState = GAME_STATE_STOPPED;
//Application.LoadLevel("MainMenu");
}
private void ondispose(GameEvent e)
{
dispose();
}
//private void onLoadReady( GameEvent e )
//{
// this.g_mgr.dispatchEvent( e );
//}
//第一次初始化游戏的时候，进来初始化地图
private void onDataInit(GameEvent e)
{
this.dispatchEvent(
GameEvent.Create(GAME_EVENT.SPRITE_SET_DATA, this, e.data)
);
}
public void useEvent(GameEvent ge)
{
this.ge = ge;
}
public void Init()
{
// Create the basic actor instances and behavior for test.
this.witness = new Thing()
{
Name = "Witness", ID = TestThingID.Generate("testthing")
};
this.stalker1 = new Thing()
{
Name = "Stalker1", ID = TestThingID.Generate("testthing")
};
this.stalker2 = new Thing()
{
Name = "Stalker2", ID = TestThingID.Generate("testthing")
};
this.victim1 = new Thing()
{
Name = "Victim1", ID = TestThingID.Generate("testthing")
};
this.victim2 = new Thing()
{
Name = "Victim2", ID = TestThingID.Generate("testthing")
};
// Set up the rooms.
this.room1 = new Thing()
{
Name = "Room", ID = TestThingID.Generate("room")
};
this.room2 = new Thing()
{
Name = "Room 2", ID = TestThingID.Generate("room")
};
// Set up an exit connecting the two rooms.
this.exit = new Thing()
{
Name = "East Exit", ID = TestThingID.Generate("exit")
};
var exitBehavior = new ExitBehavior();
////exitBehavior.AddDestination("west", room1.ID);
////exitBehavior.AddDestination("east", room1.ID);
////this.exit.BehaviorManager.Add(exitBehavior);
this.room1.Add(this.exit);
this.room2.Add(this.exit);
// Populate the first room.
this.room1.Add(this.witness);
this.room1.Add(this.stalker1);
this.room1.Add(this.stalker2);
this.room1.Add(this.victim1);
this.room1.Add(this.victim2);
// Prepare to verify correct eventing occurs.
this.witness.Eventing.MovementRequest += (root, e) => { this.lastWitnessRequest = e; };
this.witness.Eventing.MovementEvent += (root, e) => { this.lastWitnessEvent = e; };
this.stalker1.Eventing.MovementRequest += (root, e) => { this.lastStalkerRequest = e; };
this.stalker1.Eventing.MovementEvent += (root, e) => { this.lastStalkerEvent = e; };
this.stalker2.Eventing.MovementRequest += (root, e) => { this.lastStalkerRequest = e; };
this.stalker2.Eventing.MovementEvent += (root, e) => { this.lastStalkerEvent = e; };
this.victim1.Eventing.MovementRequest += (root, e) => { this.lastVictimRequest = e; };
this.victim1.Eventing.MovementEvent += (root, e) => { this.lastVictimEvent = e; };
this.victim2.Eventing.MovementRequest += (root, e) => { this.lastVictimRequest = e; };
this.victim2.Eventing.MovementEvent += (root, e) => { this.lastVictimEvent = e; };
}
