public override void SetResponse(InputResponse response)
{
FieldList[0].PreviousMsg = FieldList[0].Msg;
FieldList[0].Msg = response.Msg;
NeedsRedrawing = true;
DrawBorder = false;
}
// Dictionary<string, InteractableObject> UseDictionary;
void use(string[] parameters)
{
Player player = game.Player;
Room currentRoom = player.PlayerLocation;
foreach (string item in parameters)
{
var examineInventory = ItemsinInventory.Where(p => p.Name.ToLower() == item).ToList();
if (examineInventory.Count > 0)
{
foreach (StoryItem inventoryItem in examineInventory)
{
if (inventoryItem is Consumable)
{
Consumable consumableItem = (Consumable)inventoryItem;
InputResponse.AppendFormat($"{consumableItem.actions["use"]} \n");
player.Health += consumableItem.healthBoost;
}
else if (inventoryItem is ItemKey)
{
UseKey((ItemKey)inventoryItem, currentRoom);
}
}
}
else
{
InputResponse.AppendFormat("There is no {0} here.\n", item);
}
}
}
internal Task SendResponseAsync(InputResponse response, CancellationToken cancellationToken = default)
{
return(this.SendResponseAsync(response,
() =>
{
return this.Dialog.SendResponseAsync(response, cancellationToken);
}));
}
internal void SendResponse(InputResponse response)
{
this.SendResponse(response,
() =>
{
this.Dialog.SendResponse(response);
});
}
public IInputRespondedProcessState Respond(Action <MessageReceivedEventArgs <InputMessage> > inputFinishedCallback,
IEnumerable <InputResponseArticle> articles)
{
this.OnStateChange();
InputResponse response = new InputResponse(this.Request, articles);
return(new InputRespondedProcessState(this.Workflow, this.Request, response, inputFinishedCallback));
}
public Task <IInputRespondedProcessState> RespondAsync(Action <MessageReceivedEventArgs <InputMessage> > inputFinishedCallback,
IEnumerable <InputResponseArticle> articles,
CancellationToken cancellationToken = default)
{
this.OnStateChange();
InputResponse response = new InputResponse(this.Request, articles);
return(Task.FromResult <IInputRespondedProcessState>(new InputRespondedProcessState(this.Workflow, this.Request, response, inputFinishedCallback)));
}
private void btnOK_Click(object sender, System.EventArgs e)
{
InputResponse = this.txtInput.Text;
Parameter pass = ParameterBL.GetParameterValue("PasswordProfilesDelete");
if (InputResponse.Equals(pass.Values))
{
if (!string.IsNullOrEmpty(firstStarName) && string.IsNullOrEmpty(secondStarName))
{
DialogResult result = MessageBox.Show(string.Format("¿DESEAS BORRAR LA ESTRELLA DE PRIMER NIVEL {0}?", firstStarName), Resources.Constants.MYCTS, MessageBoxButtons.YesNo, MessageBoxIcon.Information);
if (result.Equals(DialogResult.Yes))
{
Delete1stLevelBL.Delete1stLevel(pcc, firstStarName);
//Active1stLevelBL.Active1stLevel(pcc, firstStarName);
SetProfileChangesBL.SetProfile(Login.PCC, Login.Agent, firstStarName, string.Empty, DateTime.Now);
CatAllStarsBL.ListAllStars.Clear();
LoaderProfiles.AddToPanel(LoaderProfiles.Zone.Modal_Profile, this, Resources.Profiles.Constants.UC_WELCOME_PROFILES);
}
}
else if (!string.IsNullOrEmpty(firstStarName) && !string.IsNullOrEmpty(secondStarName))
{
DialogResult result = MessageBox.Show(string.Format("¿DESEAS BORRAR LA ESTRELLA DE SEGUNDO NIVEL {0}?", secondStarName), Resources.Constants.MYCTS, MessageBoxButtons.YesNo, MessageBoxIcon.Information);
if (result.Equals(DialogResult.Yes))
{
Delete2ndLevelBL.Delete2ndLevel(secondStarName);
//Active2ndLevelBL.Active2ndLevel(pcc, firstStarName, secondStarName);
SetProfileChangesBL.SetProfile(Login.PCC, Login.Agent, firstStarName, secondStarName, DateTime.Now);
bool noSecondStar = true;
List <CatAllStars> Star2Count = CatAllStarsBL.GetAll2ndStarDetailed_Profile(ucProfileSearch.star1Info[0].Pccid, ucProfileSearch.star1Info[0].Level1, Login.OrgId);
if (Star2Count != null)
{
foreach (CatAllStars item in Star2Count)
{
if (item.Active)
{
noSecondStar = false;
break;
}
}
}
if (noSecondStar)
{
Update1stLevelBL.Update1stLevel(pcc, firstStarName, string.Empty, 2);
}
LoaderProfiles.AddToPanel(LoaderProfiles.Zone.Modal_Profile, this, Resources.Profiles.Constants.UC_WELCOME_PROFILES);
}
}
}
else
{
MessageBox.Show(Resources.Profiles.Constants.PASSWORD_ERROR, Resources.Constants.MYCTS, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
this.Close();
}
public static InputResponse ProcessArenaInput(this Actor Actor, ConsoleKey Key, MapsContainer Maps)
{
_currentActor = Actor;
InputResponse response = new InputResponse();
response.MsgWindowType = WindowType.TopMsg;
response.Actor = _currentActor;
response.Redraw = true;
MoveActor(Actor, Key, Maps, response);
return(response);
}
public void UseKey(ItemKey key, Room currentRoom)
{
foreach (Exit door in currentRoom.Exits)
{
if (door.IsLocked && door.ExitKey.ID == key.ID)
{
door.IsLocked = false;
InputResponse.AppendFormat($"You use the {key.Name} and the {door.Name} unlocks.");
}
}
}
private void SetMsgs(InputResponse response, IEnumerable <ConsoleWindowBase> WindowList)
{
var window = WindowList.FirstOrDefault(x => x.WindowType == response.MsgWindowType);
if (window == null)
{
return;
}
window.SetResponse(response);
}
public static void Init()
{
instance = new GameObject("VRManager");
instance.AddComponent <MPEventSystemProvider>().fallBackToMainEventSystem = true;
InputResponse inputResponse = instance.AddComponent <InputResponse>();
inputResponse.inputActionNames = new string[] { "RecenterHMD" };
inputResponse.onPress = new UnityEvent();
inputResponse.onPress.AddListener(Recenter);
Object.DontDestroyOnLoad(instance);
}
public IInputStartedProcessState StartProcess(IEnumerable <InputRequestArticle> articles,
bool?isNewDelivery,
bool?setPickingIndicator)
{
InputRequest request = this.CreateRequest(articles, isNewDelivery, setPickingIndicator);
InputResponse response = this.SendRequest(request,
() =>
{
return(this.Dialog.SendRequest(request));
});
return(new InputStartedProcessState(this, request, response));
}
public async Task <IInputStartedProcessState> StartProcessAsync(IEnumerable <InputRequestArticle> articles,
bool?isNewDelivery,
bool?setPickingIndicator,
CancellationToken cancellationToken = default)
{
InputRequest request = this.CreateRequest(articles, isNewDelivery, setPickingIndicator);
InputResponse response = await this.SendRequestAsync(request,
() =>
{
return(this.Dialog.SendRequestAsync(request, cancellationToken));
}).ConfigureAwait(continueOnCapturedContext: false);
return(new InputStartedProcessState(this, request, response));
}
private static void Move(Actor Actor, InputResponse Response, MapsContainer Maps, ConsoleKey Key)
{
var newCoord = GetNewCoordination(Coordinates.NewCoord(Actor.Location.X, Actor.Location.Y), Key);
_currentMsg = _moveUp;
var tile = CheckMovement(newCoord, Maps) as ArenaTile;
if (tile.Passable)
{
MoveActorToLocation(newCoord);
Response.Msg = "You move";
}
else
{
Response.Msg = string.Format("You hit a {0}", tile.Name);
}
}
public InputRespondedProcessState(InputWorkflow workflow,
InputRequest request,
InputResponse response,
Action <MessageReceivedEventArgs <InputMessage> > inputFinishedCallback)
{
this.Workflow = workflow;
this.Request = request;
this.Response = response;
this.Interceptor = new MessageInterceptor <InputMessage>(this.Workflow.Dialog,
new MessageFilter(this.Request.Id),
(MessageReceivedEventArgs <InputMessage> e) =>
{
inputFinishedCallback(e);
});
this.Workflow.SendResponse(this.Response,
() =>
{
this.Workflow.Dialog.SendResponse(response);
});
}
public bool? EvaluateGamePadThumbStickCondition(string conditionName, InputResponse response)
{
if (!_inputConditions.ContainsKey(conditionName)) return false;
GamePadThumbStickCondition condition = (GamePadThumbStickCondition)_inputConditions[conditionName];
if (condition == null) return false;
GamePadState state;
switch (condition.Player)
{
case PlayerIndex.One:
state = response.GamePadStates[1];
return EvaluateGamePadThumbStickCondition(condition, state);
case PlayerIndex.Two:
state = response.GamePadStates[2];
return EvaluateGamePadThumbStickCondition(condition, state);
case PlayerIndex.Three:
state = response.GamePadStates[3];
return EvaluateGamePadThumbStickCondition(condition, state);
case PlayerIndex.Four:
state = response.GamePadStates[4];
return EvaluateGamePadThumbStickCondition(condition, state);
}
return null;
}
private void ProcessResponse(InputResponse response, IEnumerable <ConsoleWindowBase> WindowList)
{
SetMsgs(response, WindowList);
}
public InputStartedProcessState(InputWorkflow workflow, InputRequest request, InputResponse response)
{
this.Workflow = workflow;
this.Request = request;
this.Response = response;
}
private static void MoveActor(Actor Actor, ConsoleKey Key, MapsContainer Maps, InputResponse Response)
{
switch (Key)
{
case ConsoleKey.W:
case ConsoleKey.S:
case ConsoleKey.A:
case ConsoleKey.D:
Move(Actor, Response, Maps, Key);
break;
default:
return;
}
}
public void SendResponse(InputResponse response)
{
base.SendResponse(response);
}
public void ResolveInput(InputResponse response)
{
Vector3 destination;
Vector3[] groupMoveDest;
switch (response)
{
case InputResponse.Select:
if (!upgradeManager.CheckIfGuiCick(Input.mousePosition))
{
if (selectedSoldiers.Count > 0)
{
Deselect();
}
CalculateSelectOrder();
}
break;
case InputResponse.AttackMove:
if (CalculateMoveDestination(out destination))
{
if (selectedSoldiers.Count > 1)
{
groupMoveDest = CalculateGroupMove(destination);
for (int i = 0; i < selectedSoldiers.Count; i++)
{
selectedSoldiers[i].SetAttackMove(new Vector3(groupMoveDest[i].x, selectedSoldiers[i].transform.position.y, groupMoveDest[i].z));
}
}
else if (selectedSoldiers != null && selectedSoldiers.Count >0)
{
selectedSoldiers[0].SetAttackMove(new Vector3(destination.x, selectedSoldiers[0].transform.position.y, destination.z));
}
}
break;
case InputResponse.Move:
if (CalculateMoveDestination(out destination))
{
if (selectedSoldiers.Count > 1)
{
groupMoveDest = CalculateGroupMove(destination);
for (int i = 0; i < selectedSoldiers.Count; i++)
{
selectedSoldiers[i].SetMove(new Vector3(groupMoveDest[i].x, selectedSoldiers[i].transform.position.y, groupMoveDest[i].z));
}
}
else
selectedSoldiers[0].SetMove(new Vector3(destination.x, selectedSoldiers[0].transform.position.y, destination.z));
}
break;
case InputResponse.ViewUp:
cameraMover.Pan(new Vector2(0.0f, 1.0f));
break;
case InputResponse.ViewDown:
cameraMover.Pan(new Vector2(0.0f, -1.0f));
break;
case InputResponse.ViewLeft:
cameraMover.Pan(new Vector2(-1.0f, 0.0f));
break;
case InputResponse.ViewRight:
cameraMover.Pan(new Vector2(1.0f, 0.0f));
break;
case InputResponse.Cancel:
break;
case InputResponse.BuildMenu:
break;
default:
break;
}
}
public override void SetResponse(InputResponse response)
{
}
public Task SendResponseAsync(InputResponse response, CancellationToken cancellationToken = default)
{
return(base.SendResponseAsync(response, cancellationToken));
}
public void ResolveInput(InputResponse response, Rect selectBox)
{
if (response == InputResponse.DragSelect)
{
foreach (Soldier soldier in soldierController.soldiers)
{
Vector3 unitScreenPos = Camera.main.WorldToScreenPoint(soldier.transform.position);
unitScreenPos.y = Screen.height - unitScreenPos.y;
if (!selectedSoldiers.Contains(soldier) && selectBox.Contains(unitScreenPos))
{
selectedSoldiers.Add(soldier);
soldier.selected = true;
}
}
}
}
public MenuItem(string prompt, InputResponse response, int trigger)
{
Prompt = prompt;
Response = response;
Trigger = trigger;
}
public void ResolveInput(InputResponse response, float zoomAmount)
{
cameraMover.Zoom(zoomAmount);
}
public virtual void SetResponse(InputResponse response)
{
}
