public override Task ExecuteBindingAsync(Controllers.HttpActionContext actionContext, CancellationToken cancellationToken)
{
return _traceWriter.TraceBeginEndAsync(
actionContext.ControllerContext.Request,
TraceCategories.ModelBindingCategory,
TraceLevel.Info,
_innerBinding.GetType().Name,
ExecuteBindingAsyncMethodName,
beginTrace: null,
execute: () => _innerBinding.ExecuteBindingAsync(actionContext, cancellationToken),
endTrace: (tr) =>
{
if (!actionContext.ModelState.IsValid)
{
tr.Message = Error.Format(SRResources.TraceModelStateInvalidMessage,
FormattingUtilities.ModelStateToString(
actionContext.ModelState));
}
else
{
if (actionContext.ActionDescriptor.GetParameters().Count > 0)
{
tr.Message = Error.Format(SRResources.TraceValidModelState,
FormattingUtilities.ActionArgumentsToString(
actionContext.ActionArguments));
}
}
},
errorTrace: null);
}
public void Start()
{
ivr = GetComponent <InstantVR>();
ivr.SetPlayerHeight(playerHeight);
Debug.Log("Please press <tab> to calibrate player height.");
headMovements = ivr.headTarget.GetComponent <HeadMovements>();
#if INSTANTVR_ADVANCED
leftHandMovements = ivr.leftHandTarget.GetComponent <IVR_HandMovements>();
rightHandMovements = ivr.rightHandTarget.GetComponent <IVR_HandMovements>();
#endif
// get the first player's controller
controller0 = Controllers.GetController(0);
// register for button down events
controller0.left.OnButtonDownEvent += OnButtonDownLeft;
controller0.right.OnButtonDownEvent += OnButtonDownRight;
// register for button up events
controller0.left.OnButtonUpEvent += OnButtonUpLeft;
controller0.right.OnButtonUpEvent += OnButtonUpRight;
#if INSTANTVR_ADVANCED
if (walkingType == WalkTypes.PointingTeleport)
{
pointingDevice = GetPointingDevice();
}
#endif
}
public TableGridPopupMenu(System.Windows.Forms.Control form, Controllers.TableGridCaseAdapter tableGridCaseAdapter)
: base(form)
{
m_tableGridCaseAdapter = tableGridCaseAdapter;
m_gridView = (DevExpress.XtraGrid.Views.Grid.GridView)m_tableGridCaseAdapter.CurrentGridControl.MainView;
m_gridView.PopupMenuShowing += new PopupMenuShowingEventHandler(this.gridViewShowGridMenu);
}
public EmailContactControl(Controllers.EmailElement emailElement)
{
this.InitializeComponent();
EmailElement = emailElement;
UpdateControlInfo();
}
private void buttonApply_Click(object sender, EventArgs e)
{
if (Running_Mapping.Count == 0)
{
DumpValues();
if (checkedListBox_controllerlist.CheckedIndices.Count > 0)
{
Profile tmpprofile = new Profile(Config);
tmpprofile.Start();
if (tmpprofile.IsValid && tmpprofile.IsCompiled)
{
List <int> selected_cons = new List <int>();
foreach (int i in checkedListBox_controllerlist.CheckedIndices)
{
selected_cons.Add(i);
}
foreach (var sel_con in selected_cons)
{
Controller con = Controllers.Get((int)sel_con);
con.MapToProfile(tmpprofile);
con.Start();
}
Running_Mapping.Add(new KeyValuePair <Profile, List <int> >(tmpprofile, selected_cons));
}
else
{
Logger.Log("Profile is InValid or not compiled");
}
}
else
{
MessageBox.Show("No controllers selected!");
}
}
}
public ControlCommandItem(Controllers.Commands.ControllerCommandTypes CommandType, System.Windows.Forms.Control Control)
: base(CommandType)
{
_control = Control;
_control.Click += new EventHandler(_control_Click);
}
private void Controllers_Installed(object sender, GameControllerEventArgs args)
{
var game = args.Controller.Game;
logger.Info($"Game {game.Name} installed after {args.EllapsedTime} seconds.");
var dbGame = database.GetGame(game.Id);
dbGame.State.Installing = false;
dbGame.State.Installed = true;
dbGame.InstallDirectory = args.Controller.Game.InstallDirectory;
if (dbGame.PlayTask == null)
{
dbGame.PlayTask = args.Controller.Game.PlayTask;
}
if (dbGame.OtherTasks == null)
{
dbGame.OtherTasks = args.Controller.Game.OtherTasks;
}
database.UpdateGameInDatabase(dbGame);
Controllers.RemoveController(args.Controller);
}
public IEnumerator GenerateRandom(int floorNumber)
{
Stopwatch stopWatch = Stopwatch.StartNew();
System.Random rnd = new System.Random();
DungeonStruct dungeonStructure = new DungeonStruct(300, 150);
yield return(null);
dungeonStructure = SetDungeonSize(floorNumber);
Map newMap = new Map(dungeonStructure, dungeonStructure.dungeon.Length, dungeonStructure.dungeon[0].Length, this);
currentMap = newMap;
mainCamera.transform.position = new Vector3(hero.transform.position.x, hero.transform.position.y, -10);
mainCamera.GetComponent <SmoothCamera>().target = hero.gameObject.transform.GetChild(0);
UpdateHeroHealthGUI();
UpdateHeroGoldGUI();
UpdateHeroKillsGUI();
UpdateHeroItemSlots();
PlayInMap();
loadingScreen.GetComponent <LoadingScreen>().FadeOut();
currentController = Controllers.player;
stopWatch.Stop();
debugLogManager.AddLog("World generated in: " + stopWatch.Elapsed.TotalMilliseconds.ToString() + "ms");
yield return(null);
}
public int AddBlockType(BlockController controller)
{
int index = Controllers.Count;
if (index == ushort.MaxValue)
{
Debug.LogError("Too many block types!");
return(-1);
}
if (Names.ContainsKey(controller.Name()))
{
Debug.LogError("Two blocks with the same name " + controller.Name() + " are defined!");
return(-1);
}
Controllers.Add(controller);
BlockOverride blockOverride = GetBlockOverride(controller.Name());
if (blockOverride != null)
{
blockOverride.m_Controller = controller;
}
BlockOverrides.Add(blockOverride);
Names.Add(controller.Name().ToLower().Replace(" ", ""), index);
return(index);
}
private void Awake()
{
alive = true;
_controls = new Controllers();
Speed = 1;
_transform = GetComponent <Transform>();
_animator = GetComponentInChildren <Animator>();
biteAnimator = BiteAttack.GetComponent <Animator>();
AttackDamage = 50;
Health = maxHealth;
HealthBar.SetMaxHealth(maxHealth);
HealthBar.SetHealth(maxHealth);
Hunger = maxHunger;
HungerBar.SetMaxHunger(maxHunger);
HungerBar.SetHunger(maxHunger);
StartCoroutine("HungerGrowing");
Venom = maxVenom;
VenomBar.SetMaxVenom(maxVenom);
VenomBar.SetVenom(maxVenom);
facing = "down";
}
public FormMain(Controllers.MainController mainController)
{
// TODO: Complete member initialization
this.mainController = mainController;
InitializeComponent();
}
protected override void CreateControllers(dynamic data)
{
var playerController = new VideoPlayerController();
playerController.SetViewModel(ViewModel.VideoPlayer);
Controllers.Add(playerController);
}
public static void SetSession(Controllers.Models.User user)
{
if (HttpContext.Current.Session["User_Data"] == null)
{
HttpContext.Current.Session.Add("User_Data", user);
}
}
/// <summary>
/// Constructor, initialize the UI
/// </summary>
public SettingsWindow()
{
InitializeComponent();
var controllers = Controllers.ListControllers();
var activeControllerName = HexLight.Properties.Settings.Default.Controller;
// Populate the listbox
cbDrivers.Items.Clear();
//cbDrivers.Items.Add(ControllerItem.NullController);
//if (activeControllerName == null || activeControllerName == "")
// cbDrivers.SelectedIndex = 0;
foreach (var controllerType in controllers)
{
var item = new ControllerItem(controllerType);
cbDrivers.Items.Add(item);
if (controllerType.FullName == activeControllerName)
{
cbDrivers.SelectedItem = item;
}
}
//TODO: Use ValueConverters and Bindings ?
}
public ControllersBehaviour()
{
var types = new[]
{
typeof(System.Web.Mvc.Controller),
typeof(MvcController),
typeof(WebApiController),
typeof(TestController),
typeof(NonServicesTestController)
}.AsQueryable();
var servicesTypes = new[]
{
typeof(TestController),
typeof(NonServicesTestController)
}.AsQueryable();
var typeProvider = new Mock <ITypeProvider>();
var servicesTypeProvider = new Mock <ITypeProvider>();
typeProvider
.SetupGet(x => x.Types)
.Returns(types);
servicesTypeProvider
.SetupGet(x => x.Types)
.Returns(servicesTypes);
_sut = new Controllers(typeProvider.Object, servicesTypeProvider.Object);
}
public static void Initialize()
{
if (Axes == null)
{
Axes = new List <Axis>()
{
new Axis('X'),
new Axis('Y'),
new Axis('Z'),
new Axis('A'),
new Axis('B')
};
}
if (Motors == null)
{
Motors = new List <Motor>()
{
new Motor(Axes[0]),
new Motor(Axes[1]),
new Motor(Axes[2]),
new Motor(Axes[3]),
new Motor(Axes[4])
};
}
Controllers.Initialize();
}
public ToolStripCommandItem(Controllers.Commands.ControllerCommandTypes CommandType, System.Windows.Forms.ToolStripItem ToolStripItem)
: base(CommandType)
{
_toolStripItem = ToolStripItem;
_toolStripItem.Click += new EventHandler(_toolStripItem_Click);
}
public void InstallGame(Game game)
{
logger.Info($"Installing {game.GetIdentifierInfo()}");
IGameController controller = null;
try
{
controller = GameControllerFactory.GetGameBasedController(game, appSettings);
Controllers.RemoveController(game.Id);
Controllers.AddController(controller);
UpdateGameState(game.Id, null, null, true, null, null);
controller.Install();
}
catch (Exception exc) when(!PlayniteEnvironment.ThrowAllErrors)
{
if (controller != null)
{
Controllers.RemoveController(game.Id);
UpdateGameState(game.Id, null, null, false, null, null);
}
logger.Error(exc, "Cannot install game: ");
dialogs.ShowMessage(
string.Format(resources.FindString("LOCGameInstallError"), exc.Message),
resources.FindString("LOCGameError"),
MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public ControllersBehaviour()
{
var types = new[]
{
typeof(System.Web.Mvc.Controller),
typeof(MvcController),
typeof(WebApiController),
typeof(TestController),
typeof(NonServicesTestController)
}.AsQueryable();
var servicesTypes = new[]
{
typeof(TestController),
typeof(NonServicesTestController)
}.AsQueryable();
var typeProvider = new Mock<ITypeProvider>();
var servicesTypeProvider = new Mock<ITypeProvider>();
typeProvider
.SetupGet(x => x.Types)
.Returns(types);
servicesTypeProvider
.SetupGet(x => x.Types)
.Returns(servicesTypes);
_sut = new Controllers(typeProvider.Object, servicesTypeProvider.Object);
}
private void OnGetContext(HttpListenerContext context)
{
var guid = context.Request.GetSessionGuid();
Session session;
lock (this)
{
if (guid == Guid.Empty || !_sessions.TryGetValue(guid, out session))
{
session = new Session(context.Request.RemoteEndPoint?.Address);
context.Response.SetSessionGuid(session.Guid);
_sessions.Add(session.Guid, session);
}
}
var matched = Controllers
.GetMatching(session, context.Request)
.FirstOrDefault(matching => matching.Service(context, session));
if (matched == null)
{
throw new NotImplementedException();
}
}
private void OnDestroy()
{
Controllers.OnOriginDestroyed();
HMD.OnOriginDestroyed();
FocusStateEvents.OnFocusStateChange -= FocusStateChanged;
Snapturn.OnSnapTurn += HandleOriginShift;
}
public bool ScanForControllers()
{
bool foundSome = false;
var list = manager.GetDevices(DI.DeviceClass.GameController, DI.DeviceEnumerationFlags.AttachedOnly);
foreach (DI.DeviceInstance d in list)
{
bool found = false;
foreach (var cc in Controllers)
{
if (cc.Device.Information.InstanceGuid == d.InstanceGuid)
{
found = true;
break;
}
}
if (found)
{
continue;
}
Console.WriteLine("Found gamepad " + d.InstanceName + "...");
Controllers.Add(new InputController(this, new DI.Joystick(manager, d.InstanceGuid), Controllers.Count));
foundSome = true;
}
return(foundSome);
}
private void SetupOrigin()
{
Controllers.SetOrigin(transform);
HMD.SetOrigin(transform);
DontDestroyOnLoad(gameObject);
Log.Info("Origin created and set");
}
public Controllers.EmployeeBase AddEmployee(Controllers.EmployeeAdd newItem)
{
// Use the repository method to add a new employee
var addedItem = m.Employees.AddNew(newItem);
return addedItem;
}
private void LoadController(IApplication application)
{
Utils.LoadAssembly(a =>
{
foreach (Type type in a.GetTypes())
{
if (IKende.IKendeCore.GetTypeAttributes <ControllerAttribute>(type, false).Length > 0 && !type.IsAbstract)
{
"load {0} controller".Log4Info(type);
object controller = Activator.CreateInstance(type);
Controllers.Add(controller);
foreach (System.Reflection.MethodInfo method in type.GetMethods(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance))
{
try
{
ParameterInfo[] pis = method.GetParameters();
if (pis.Length == 2 && (pis[0].ParameterType == typeof(ISession)))
{
IMethodHandler handler = new MethodHandler(controller, method, application);
mControllerHandlers[pis[1].ParameterType] = handler;
"load {0}->{1} action success".Log4Info(type, method.Name);
}
}
catch (Exception e_)
{
"load {0}->{1} action error".Log4Error(e_, type, method.Name);
}
}
}
}
});
}
public void ReadSettings()
{
UserPreference = JsonConvert.DeserializeObject <UserPreference>(Properties.Settings.Default["preference"].ToString());
List <IController> all_ctrls = new List <IController>();
if (UserPreference != null)
{
Type t = typeof(Helper);
string ns = t.Namespace;
foreach (string vendor in UserPreference.Vendors)
{
AccountOption accOpt = (dynamic)UserPreference.GetType().GetProperty(vendor + "Account").GetValue(UserPreference);
foreach (var acc in accOpt.Accounts)
{
if (acc.IsActivate)
{
string clsName = ns + "." + vendor + "Controller";
Type type = Type.GetType(clsName);
IController ctrl = Activator.CreateInstance(type, this) as IController;
ctrl.ConnParam = acc;
// if some connection is connected, then remain unchanged
IController ic = Controllers.FirstOrDefault(x => x.DisplayName == ctrl.DisplayName);
if (ic != null)
{
ic.ConnParam = acc;
all_ctrls.Add(ic);
}
else
{
all_ctrls.Add(ctrl);
}
}
}
// add new controllers
foreach (var ctrl in all_ctrls)
{
IController ic = Controllers.FirstOrDefault(x => x.DisplayName == ctrl.DisplayName);
if (ic == null)
{
Controllers.Add(ctrl);
}
}
// remove out-of-date controllers
foreach (var ctrl in Controllers.ToList())
{
IController ic = all_ctrls.FirstOrDefault(x => x.DisplayName == ctrl.DisplayName);
if (ic == null)
{
foreach (var symbol in SymbolInActions)
{
symbol.AppliedControllers.Remove(ctrl);
}
Controllers.Remove(ctrl);
}
}
}
}
}
protected virtual void OnProcess(RPCPacket response)
{
var awaitItem = mAwaiterFactory.GetItem(response.ID);
if (awaitItem != null)
{
response.ResultType = awaitItem.ResultType;
try
{
response.LoadParameters(response.ResultType);
}
catch (Exception e_)
{
response.Status = (short)StatusCode.INNER_ERROR;
response.Data = new object[] { $"{e_.Message}@{e_.StackTrace}" };
}
mAwaiterFactory.Completed(awaitItem, response);
}
else
{
try
{
if (response.Url.IndexOf(DELEGATE_TAG, StringComparison.OrdinalIgnoreCase) == 0)
{
InvokeDelegate(response);
return;
}
//notfound;
var item = Controllers.GetHandler(response.Url);
if (item != null)
{
InvokeController(item, response);
}
else
{
if (Receive != null)
{
Receive(this, response);
}
else
{
if (response.NeedReply)
{
var result = new RPCPacket();
result.Status = (short)StatusCode.NOT_SUPPORT;
result.Data = new object[] { $"{response.Url} not found!" };
response.ReplyPacket(result);
}
}
}
}
catch (Exception e_)
{
OnError(response.Client, new ClientErrorArgs {
Error = e_, Message = $"Packet process event error {e_.Message}"
});
}
}
}
public void Clear()
{
Files.Clear();
Routings.Clear();
Controllers.Clear();
ConditionalRouting.Clear();
ConditionalPassthroughs.Clear();
}
static void Main(string[] args)
{
Models Model = new Models();
Views ViewInput = new Views();
Views ViewIntfr = new Views();
Controllers controller = new Controllers(Model, ViewInput, ViewIntfr);
}
public static void UpdateObjectives(string mainObj, string subObj)
{
if (objectiveDisplay != null)
{
objectiveDisplay.text = "WARDEN OBJECTIVE: \n \n " + mainObj + "\n \n " + subObj;
VRInput.TriggerHapticPulse(0.01f, 1 / .025f, 0.2f, Controllers.GetDeviceFromType(Controllers.offHandControllerType));
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void SetRectLayout(float pSizeX, float pSizeY, ISettingsController pController)
{
Controllers.Set(SizeXName, pController);
Controllers.Set(SizeYName, pController);
SizeX = (FlipLayoutDimensions ? pSizeY : pSizeX);
SizeY = (FlipLayoutDimensions ? pSizeX : pSizeY);
}
public void GetControllers(HttpContext context)
{
Controllers controllers = _controllerHandler.GetControllers(context.Request.ParsedQuery);
string json = JsonSerializer.SerializeJson(controllers);
context.Response.Payload.Write(json);
context.Response.Status = HttpStatus.OK;
}
private void addDefaultKeyboardControllers()
{
Controllers.Add(new NullObjectController("NONE"));
Controllers.Add(new KeyboardController(0, Keyboard.GetState(), Key.Up, Key.Down, Key.Left,
Key.Right, Key.Comma, Key.Period, Key.RShift, Key.Space));
Controllers.Add(new KeyboardController(1, Keyboard.GetState(), Key.W, Key.S, Key.A, Key.D,
Key.T, Key.Y, Key.LShift, Key.H));
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void SetRectLayout(float pSizeX, float pSizeY, ISettingsController pController)
{
Controllers.Set(SizeXName, pController);
Controllers.Set(SizeYName, pController);
SizeX = pSizeX;
SizeY = pSizeY;
}
/*--------------------------------------------------------------------------------------------*/
public void TreeUpdate()
{
RectTransform rectTx = TextComponent.rectTransform;
rectTx.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, SizeX / CanvasScale);
rectTx.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, SizeY / CanvasScale);
Controllers.TryExpireControllers();
}
Move waitInput(Controllers controller)
{
if (controller == Controllers.AI)
{
//타이머
System.Timers.Timer timer = null;
if (isCheckedTimer)
{
timer = new System.Timers.Timer();
timer.Elapsed += Timer_Elapsed;
timer.Interval = maxGivenTime * 1000;
timer.Start();
}
//최대 탐색 노드 설정
mcts.MaxVisitCount = maxVisitCount;
//탐색 시작
var task = mcts.SearchNextAsync();
if (stepByStep)
{
PauseSearching();
}
task.Wait();
timer?.Stop();
timer = null;
return(task.Result.prevMove);
}
else if (controller == Controllers.Human)
{
Task <Node> task = null;
if (thinkAlways)
{
mcts.MaxVisitCount = int.MaxValue;
task = mcts.SearchNextAsync();
}
StageMain.IsMovable = true;
//사용자 입력을 기다린다.
userWaiter.WaitOne();
StageMain.IsMovable = false;
if (mcts != null)
{
mcts.ForceStopSearch();
}
task?.Wait();
return(userMove);
}
else
{
throw new Exception("undefined controller");
}
}
private void Controllers_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (Controllers.SelectedIndex > -1)
{
Controllers.ScrollIntoView(Controllers.SelectedItem);
}
Condition.Cond = null;
Condition.Reload();
}
private unsafe static bool OurScannerMethod(IntPtr thisPtr, int maxTags, out IntPtr enemies)
{
cachedControllerRotation = Controllers.GetControllerAimRotation();
inBioScannerFunction = true;
bool result = OriginalScannerMethod(thisPtr, maxTags, out enemies);
inBioScannerFunction = false;
return(result);
}
public BuildStatusConfig()
{
Settings = new Settings();
Schedules = new Schedules();
Controllers = new Controllers();
Monitors = new Monitors();
Visualisers = new Visualisers();
Transitions = new Transitions();
}
public void Seek(float seekPoint)
{
Controllers.CancelInvoke();
Controllers.Invoke("FadeOutFunction", 3f);
Debug.Log("Seeking: " + (long)(seekPoint * (float)videoPlayer.frameCount) + " out of " + videoPlayer.frameCount);
videoPlayer.frame = (long)(seekPoint * (float)videoPlayer.frameCount);
videoPlayer.Play();
StartCoroutine(playButton.FadeOut());
}
public Form1(Point pos, Size size, Controllers.Form1 controller)
: base("Form1", pos, size)
{
this.Closing += new EventListener(Form1_Closing);
panel = new ScrolledWindow(this, (int)ID_CONTROLS.ID_PANEL /*, wxDefaultPosition, wxDefaultSize, WindowStyles.TAB_TRAVERSAL | WindowStyles.CLIP_CHILDREN | WindowStyles.BORDER_NONE*/);
panel.AutoLayout = true;
// At this point we don't know about the Model (so we don't have any labels etc..) so we have to wait for the model to get in touch
text = new TextCtrl(panel, (int)ID_CONTROLS.ID_TEXT, string.Empty, wxDefaultPosition, wxDefaultSize, wx.WindowStyles.TE_MULTILINE | wx.WindowStyles.BORDER_SUNKEN);
}
public Statistics(Controllers.MainController mc)
{
InitializeComponent();
this.mc = mc;
radioButton3.CheckedChanged += WeeklyRadioButtons;
dateTimePicker1.Value = dateTimePicker1.Value.AddDays(-7);
groupBox3.MaximumSize = new System.Drawing.Size(242, 10000);
UpdateYearPage();
UpdateMonthPage();
}
public void Run(Controllers.IWebSocketEventSender websocket, Models.ApiProcessSpec apiProcessSpec)
{
container.StartGuard();
var processSpec = NewProcessSpec(apiProcessSpec);
CopyProcessSpecEnvVariables(processSpec, apiProcessSpec.Env);
OverrideEnvPort(processSpec);
var process = Run(websocket, processSpec);
if (process != null)
WaitForExit(websocket, process);
}
public XtraGrid(Controllers.Controller Controller)
{
_controller = Controller;
InitializeUI();
Controller.ListUIUploadToExcel += new DataAvail.Controllers.ControllerListUIUploadToExcelHandler(Controller_ListUIUploadToExcel);
Controller.ListUIFilter += new DataAvail.Controllers.ControllerFilterExpressionHandler(Controller_ListUIFilter);
Controller.ListUIFilterActive += new DataAvail.Controllers.ControllerListUIFilterActiveHandler(Controller_ListUIFilterActive);
Controller.ListUIFilterFormatter += new DataAvail.Controllers.ControllerListUIFilterFormatterHandler(Controller_ListUIFilterFormatter);
Controller.EndFill += new EventHandler(Controller_EndFill);
Controller.Commands.AddCommandItems(SupportedCommands);
}
public ControlPanel(Controllers.MainController mainController)
{
// TODO: Complete member initialization
this.mainController = mainController;
InitializeComponent();
InitializeNumberPickers();
ControlBox = false;
Text = "";
Visible = true;
openFileDialog1.Filter = "Image files|*.jpg; *.jpeg; *.png; *.gif";
GetImages();
WodoPanel.Visible = false;
comboBox1.DataSource = mainController.getAllKids();
}
public override void ProcessTalk(Player player, Controllers.DialogController dialog, bool isReward)
{
if (!IsCountersComplete(player))
return;
string title = Task.JournalText.Substring(0, Task.JournalText.IndexOf(":", StringComparison.OrdinalIgnoreCase) + 1);
int titleId = int.Parse(Task.JournalText.Substring(Task.JournalText.IndexOf(":", StringComparison.OrdinalIgnoreCase) + 1)) - 1;
title = title + titleId;
if (dialog.Buttons[0].Text.Equals(title))
{
Processor.FinishStep(player);
}
else
{
dialog.Reset(3, 0, player.Quests[Quest.QuestId].Step + 1, 1 + (titleId % 1000) / 2, Quest.QuestId);
dialog.Buttons.Add(new DialogButton(DialogIcon.DefaultQuest, title));
dialog.SendDialog(Quest, Global.QuestEngine.GetRewardForPlayer(player, Quest));
}
}
public TreeListPopupMenu(System.Windows.Forms.Control form, Controllers.TreeListCaseAdapter treeListCaseAdapter)
: base(form)
{
m_treeListCaseAdapter = treeListCaseAdapter;
m_treeListCaseAdapter.m_treeList.MouseDown += new MouseEventHandler(this.treeListMouseDown);
}
public override IValueProvider GetValueProvider(Controllers.HttpActionContext actionContext)
{
throw new NotImplementedException();
}
public ExceptionLog(Controllers.ReturnObjects.GenericHitchBot context)
: this()
{
TimeOccured = context.DateTime;
HitchBotId = context.HitchBotId;
}
/// <summary>Initialize the Controller MIDI event message.</summary>
/// <param name="deltaTime">The delta-time since the previous message.</param>
/// <param name="channel">The channel to which to write the message (0 through 15).</param>
/// <param name="number">The type of controller message to be written.</param>
/// <param name="value">The value of the controller message.</param>
public Controller(long deltaTime, byte channel, Controllers number, byte value)
: this(deltaTime, channel, (byte)number, value)
{
}
public Controllers.Controller AddController(Controllers.Controller def)
{
def._next = _controllerList;
def._prev = null;
if (_controllerList != null)
_controllerList._prev = def;
_controllerList = def;
++_controllerCount;
def._world = this;
return def;
}
//Creates explosion
public void spawnExplosionParticles(Models.GameObject explodingObject, Models.Projectile projectile, Controllers.ParticleSystem particleSystem)
{
Vector2 objectPosition = explodingObject.Position;
Vector2 explosionDirection = projectile.Velocity;
particleSystem.newSpawner(content.particle_explosion, objectPosition, 1000, 0, 10, false, explosionDirection*2);
}
public TabletStatus(Controllers.ReturnObjects.GenericHitchBot context)
: this()
{
TimeTaken = context.DateTime;
HitchBotId = context.HitchBotId;
}
/// <summary>
/// Remove the specifed controller
/// </summary>
/// <param name="controller"></param>
public void RemoveController(Controllers.IController controller)
{
if (m_Controller != null)
m_Controller.RemoveController(controller);
}
/// <summary>
/// Gathers the resources.
/// </summary>
/// <param name="account">Current account.</param>
/// <param name="actionTime">Action time.</param>
/// <param name="regionManagerC">Region manager controller.</param>
/// <param name="range">Range of the building.</param>
public static void GatherResources(Account account, DateTime actionTime, Controllers.RegionManagerController regionManagerC, int range)
{
foreach (var element in account.TerritoryBuildings)
{
var list = LogicRules.GetSurroundedPositions(element.Key, range);
float scrapAmount = 0;
float plutoniumAmount = 0;
foreach (var item in list)
{
// TODO: add ressources in Terrain
var resources = regionManagerC.GetRegion(item.RegionPosition).GetTerrain(item.CellPosition);
scrapAmount += 0.5f;
plutoniumAmount += 0.3f;
}
account.Scrap.Set(actionTime, account.Scrap.GetValue(actionTime), Constants.SCRAP_INCREMENT_VALUE);
account.Plutonium.Set(actionTime, account.Plutonium.GetValue(actionTime), Constants.PLUTONIUM_INCREMENT_VALUE);
}
}
/// <summary>
/// Increases the resource generation.
/// </summary>
/// <param name="account">Current account.</param>
/// <param name="actionTime">Action time.</param>
/// <param name="entitypos">Entity position.</param>
/// <param name="regionManagerC">Region manager controller.</param>
public static void IncreaseResourceGeneration(Account account, DateTime actionTime, PositionI entitypos, Controllers.RegionManagerController regionManagerC)
{
switch (regionManagerC.GetRegion(entitypos.RegionPosition).GetEntity(entitypos.CellPosition).DefinitionID)
{
case (int)Core.Models.Definitions.EntityType.Lab:
account.Technology.Set(actionTime, account.Technology.GetValue(actionTime), Constants.TECHNOLOGY_INCREMENT_VALUE);
break;
case (int)Core.Models.Definitions.EntityType.Furnace:
account.Scrap.Set(actionTime, account.Scrap.GetValue(actionTime), Constants.SCRAP_INCREMENT_VALUE);
break;
}
}
Task<Net.Http.HttpResponseMessage> IActionFilter.ExecuteActionFilterAsync(Controllers.HttpActionContext actionContext, Threading.CancellationToken cancellationToken, Func<Threading.Tasks.Task<Net.Http.HttpResponseMessage>> continuation)
{
throw new NotImplementedException();
}
public void RemoveController(Controllers.Controller controller)
{
Box2DXDebug.Assert(_controllerCount > 0);
if (controller._next != null)
controller._next._prev = controller._prev;
if (controller._prev != null)
controller._prev._next = controller._next;
if (controller == _controllerList)
_controllerList = controller._next;
--_controllerCount;
}
/// <summary>
/// Add the specified controller
/// </summary>
/// <param name="controller"></param>
public void AddController(Controllers.IController controller)
{
if (m_Controller == null)
m_Controller = new SourceGrid.Cells.Controllers.ControllerContainer();
m_Controller.AddController(controller);
}
/// <summary>
/// Destroy the building and undo the functionality.
/// </summary>
/// <param name="entity">Current entity.</param>
/// <param name="regionPos">Region position.</param>
/// <param name="action">Action which is currently done.</param>
/// <param name="regionManagerC">Region manager controller.</param>
public static void DestroyBuilding(Entity entity, Region regionPos, Action action, Controllers.RegionManagerController regionManagerC)
{
// TODO: in pseudo klasse kapseln und generischer lösen
switch ((long)entity.DefinitionID)
{
case (long)Models.Definitions.EntityType.Headquarter:
regionPos.FreeClaimedTerritory(LogicRules.GetSurroundedPositions(entity.Position, Constants.HEADQUARTER_TERRITORY_RANGE), entity.Owner);
DecreaseWholeStorage(entity.Owner);
DisableBuildOptions(entity.DefinitionID, entity.Owner);
entity.Owner.TerritoryBuildings.Remove(entity.Position);
// TODO: bessere lösung als alles neu claimen finden
foreach (var building in entity.Owner.TerritoryBuildings)
{
var list = new HashSet<PositionI>();
var range = 0;
if (building.Value == (long)Definitions.EntityType.Headquarter)
{
range = Constants.HEADQUARTER_TERRITORY_RANGE;
}
else if (building.Value == (long)Definitions.EntityType.GuardTower)
{
range = Constants.GUARDTOWER_TERRITORY_RANGE;
}
list = GetSurroundedPositions(building.Key, range);
var region = building.Key.RegionPosition;
regionManagerC.GetRegion(region).ClaimTerritory(list, entity.Owner, region, regionManagerC.RegionManager);
}
// DestroyAllBuildingsWithoutTerritory(entity.Owner, action, regionManagerC);
break;
case (long)Models.Definitions.EntityType.GuardTower:
regionPos.FreeClaimedTerritory(LogicRules.GetSurroundedPositions(entity.Position, Constants.GUARDTOWER_TERRITORY_RANGE), entity.Owner);
entity.Owner.TerritoryBuildings.Remove(entity.Position);
// TODO: bessere lösung als alles neu claimen finden
foreach (var building in entity.Owner.TerritoryBuildings)
{
var list = new HashSet<PositionI>();
var range = 0;
if (building.Value == (long)Definitions.EntityType.Headquarter)
{
range = Constants.HEADQUARTER_TERRITORY_RANGE;
}
else if (building.Value == (long)Definitions.EntityType.GuardTower)
{
range = Constants.GUARDTOWER_TERRITORY_RANGE;
}
list = GetSurroundedPositions(building.Key, range);
var region = building.Key.RegionPosition;
regionManagerC.GetRegion(region).ClaimTerritory(list, entity.Owner, region, regionManagerC.RegionManager);
}
// DestroyAllBuildingsWithoutTerritory(entity.Owner, action, regionManagerC);
break;
case (long)Models.Definitions.EntityType.Barracks:
var count = 0;
foreach (var element in entity.Owner.Buildings)
{
if (entity.Owner.Buildings.ContainsValue(element.Value))
{
count++;
}
}
if (count == 1)
{
DisableBuildOptions(entity.DefinitionID, entity.Owner);
}
entity.Owner.Buildings.Remove(entity.Position);
break;
case (long)Models.Definitions.EntityType.Furnace:
DecreaseResourceGeneration(entity.Owner, action.ActionTime, entity.Position, regionManagerC);
entity.Owner.Buildings.Remove(entity.Position);
break;
case (long)Models.Definitions.EntityType.Factory:
entity.Owner.Buildings.Remove(entity.Position);
break;
case (long)Models.Definitions.EntityType.Attachment:
entity.Owner.Buildings.Remove(entity.Position);
break;
case (long)Models.Definitions.EntityType.Hospital:
entity.Owner.Buildings.Remove(entity.Position);
break;
case (long)Models.Definitions.EntityType.TradingPost:
entity.Owner.Buildings.Remove(entity.Position);
break;
case (long)Models.Definitions.EntityType.Tent:
DecreaseMaxPopulation(entity.Owner, entity);
entity.Owner.Buildings.Remove(entity.Position);
break;
case (long)Models.Definitions.EntityType.Lab:
DecreaseResourceGeneration(entity.Owner, action.ActionTime, entity.Position, regionManagerC);
entity.Owner.Buildings.Remove(entity.Position);
break;
case (long)Models.Definitions.EntityType.Scrapyard:
DecreaseScrap(entity.Owner, entity);
entity.Owner.Buildings.Remove(entity.Position);
break;
}
}
