Motor task skill assessment system and method

Abstract

A system and method can adjust evaluation of input signals from input devices used by game players based on performance or motor acuity. A relationship or mapping between computer input device input and movement within a virtual environment can be adjusted based on the performance indicator. Embodiments can measure or calculate a performance indicator or motor acuity of a computer game player by determining, for different target types, a speed of a player and one of an accuracy, precision, and variability of the player; and determining motor acuity based on a relationship between the speed of the player and the accuracy, precision, or variability. The calculation can use statistical analysis; and can be through creating a best fit line in a comparison of speed and variability; and transforming the best fit line into a curve in a comparison of player speed and player accuracy.

Description

Technical Field

[0001] This invention generally relates to the field of skills training and assessment. More specifically, embodiments of the invention relate to skills training and assessment in video games. Background Technology

[0002] Currently, performance metrics exist for assessing changes in motor skill performance over time or differences between players. While these metrics may have applications in gaming, physical or cognitive therapy, and other fields, they are not efficient or accurate enough. In contrast to traditional sports, there are few performance metrics available for evaluating player skills and abilities in video games and esports (e.g., competitive multiplayer video games). First-person shooter (FPS) video games center on gunfights and other weapon-based combat from a first-person perspective, where players control player characters. One skill measurement related to video games is flicking, which measures a player's ability to perform flick shots. This is a standard user input in some video games, such as a player's ability to react quickly to a target. Flicking, the act of quickly moving the crosshair to an object or enemy and firing to damage or destroy the target, is a fundamental mechanic in FPS games. Flick shots can include shooting in the following situations: the player's aiming point or crosshair is initially some distance away from the target, and the player quickly flicks the gun (e.g., by controlling a video game controller or by moving a computer mouse), causing the aiming point to move to the target, for example, almost simultaneously with the player pulling the trigger or firing.

[0003] Performance in FPS video games relies on acquired sensory and motor skills. Competitive players often invest years honing these skills before reaching a professional level. Despite the rapid growth in the popularity of competitive esports, the field still lacks universally accepted objective metrics for measuring individual skill. Many commonly used performance metrics in esports do not reliably measure individual skill. Especially in team games, key benchmarks (e.g., kill-to-death ratio, damage dealt, win rate) often confound the difference between a player's individual ability and the skill level of their teammates, the strength of the opposing team, or the overall teamwork. For example, an average player can achieve a high ranking by teaming up with a much more skilled player, while a highly skilled player may face the opposite situation when teaming up with a less skilled teammate. To accurately reflect player rankings and training effectiveness, a reliable individual skill assessment system is needed, incorporating comparisons within and between individuals, as well as single-point and longitudinal tracking.

[0004] Success in FPS games requires efficient identification and localization of relevant visual stimuli, coupled with dynamic movement and a precise timing of subsequent shooting responses. For example, when using a computer mouse and keyboard, the flicking motion is primarily achieved through hand and arm movements (e.g., reach). Protocols for measuring ballistic reach and eye-tracking kinematics are well-established and widely applied in various cognitive and visual-motor tasks. However, specific knowledge about FPS performance remains insufficient. Visual-motor skills are specific and often constrained by the context and perceptual patterns in which they are learned. Therefore, previous research in visual-motor psychophysics has limited understanding of FPS performance. Summary of the Invention

[0005] A system and method for measuring or calculating an individual's performance, performance metrics, or motor agility and visual-motor skill performance metrics in performing computer tasks, gamified tasks, or computer games through the following steps: determining a player's speed (e.g., in movement or shooting) and one of the player's precision, accuracy, and variability for multiple different target types; and determining or calculating motor agility based on the relationship between the player's speed and one of the player's or player's input precision, accuracy, and variability. The calculation may use statistical analysis; and may be achieved by creating a best-fit line in the comparison of speed and variability; and transforming the best-fit line into a curve in the comparison of player speed and player precision (1 / variability).

[0006] Some implementation schemes assess the impact of hardware, software, and various other factors (such as mouse, mousepad, rendering latency, posture, exercise, diet and dietary supplements, sleep, etc.) on game performance.

[0007] Some implementation schemes can be applied to other areas. Examples include: rehabilitation (assessment and training) for patients recovering from stroke, traumatic brain injury, or arm injury; concussion assessment to determine whether an individual may have suffered a concussion or brain injury by comparing their performance to a baseline measured before the event that may have caused the injury, or to determine whether an athlete should return to competition after a concussion; assessment, representation, and / or training for individuals learning to use prostheses; assessment, representation, and / or training for patients with mobility impairments (e.g., cerebral palsy); and gamified assessment or representation of sensorimotor and cognitive fitness or status, such as immersive games for military personnel that can run on mobile devices (phones, tablets, etc.) to assess and monitor changes in cognitive fitness, readiness, and performance throughout the military cycle and in combat environments.

[0008] A computer-implemented method for adjusting the evaluation of input signals from a computer input device used by a game player and / or performing a patient's sensorimotor or cognitive assessment or treatment, the method comprising: monitoring input in a game by a player using a computer input device, game controller, mouse, etc.; determining or calculating performance metrics or other metrics of the input; and adjusting the relationship between the input received via the computer input device and the movement of virtual objects (such as virtual characters, weapons, etc.) within the virtual environment of the game based on the performance metrics. The relationship may be, for example, one or more sensitivities of the computer input device; the number of points per inch the virtual object moves when the computer input device moves one unit, or other relationships. The adjustment may include setting one or more sensitivities on the computer input device. The performance metrics may include the distance between a projectile and a target; and the distance between the movement and the target; or other metrics. The computer input device may be, for example, a mouse; a game controller; a joystick; an accelerometer; a pointing device; a motion capture device; a Wii remote control; an eye tracker; a computer vision system; a gyroscope; an absolute positioning head-mounted device; a six-degrees-of-freedom head-mounted device; an inside-out tracking head-mounted device; or other devices. The input may include aiming or targeting movement trajectories. Adjusting the relationship may include manipulating at least one of acceleration and velocity, or other adjustments. The adjustments may include manipulating at least one of the following: the input's position, velocity, acceleration, higher-order time derivative of the position, orientation, angular velocity, angular acceleration, higher-order time derivative of the orientation, joint angle, angular velocity of the joint angle, angular acceleration of the joint angle, higher-order time derivative of the joint angle, DPI, lift-off distance, polling rate, button response / debounce time, and angle adjustment, or other adjustments. The adjustment of the relationship may be performed by a computer program including the game, the input device, or other components. The performance metrics may be, for example, movement kinematics performance metrics, shooting performance metrics, speed, accuracy, precision, variability, positional error, reaction time, motion acuity, and score. Determining the movement performance metrics may include, for example, determining the performance metrics of the movement trajectory. The performance metrics may be based on, for example, mean; median; mode; variance; covariance; skewness; kurtosis; movement speed; peak movement speed; rate of fire; a metric based on a target presentation duration threshold; a metric based on target hit rate; a metric based on the time between target spawn or appearance and the first shot fired; a metric based on movements per second; a metric based on shots per second; movement variability; shot variability; a metric based on the spatial error between the point of impact of the movement and the target; a metric based on the median absolute difference between the endpoint of the movement and the center of the target; and a metric based on a target size threshold.

[0009] A method or apparatus may perform a sensorimotor or cognitive assessment or treatment of a patient by, for example, the following steps: analyzing a time series of patient movements based on input signals from an input controller to generate multiple analyzed movements; calculating, for multiple target types, the velocity of a set of analyzed movements of the patient input, and the precision and variability of the patient input of the set of analyzed movements; calculating motor acuity based on the relationship between the velocity and precision of the patient input, wherein calculating motor acuity includes creating a best-fit straight line in a comparison of the velocity and variability of the patient input; transforming the best-fit straight line into a curve in a comparison of the patient velocity and the patient precision; and generating an assessment output characterizing the patient's sensorimotor or cognitive fitness based on the motor acuity. Determining motor acuity may include performing a statistical analysis on one of the patient's velocity and precision or variability. Determining motor acuity may include determining the distance of the curve from the origin in its plotted graph. Patient input speed may include, for example, one of the following: movement speed; peak movement speed; rate of fire; a metric based on a target presentation duration threshold; a metric based on target hit rate; a metric based on the time between target generation or appearance and the first shot fired; a metric based on movements per second; and a metric based on shots per second. Patient variability may include, for example, one of the following: motion variability; shooting variability; a metric based on the spatial error between the point of impact of the movement and the target; a metric based on the median absolute difference between the endpoint of the movement and the center of the target; and a metric based on a target size threshold. A method for performing a patient's sensorimotor or cognitive assessment or treatment may include: for multiple target types, based on the speed of patient input from an input controller to a computer processor, and one of the precision, accuracy, and variability of the patient input from the input controller to the computer processor; characterizing changes in motor acuity by performing a multiple linear regression on the speed of patient input and one of the precision, accuracy, and variability of patient input; and generating an assessment output characterizing the patient's sensorimotor or cognitive fitness based on motor acuity. Attached Figure Description

[0010] The subject matter considered to be the present invention is specifically pointed out and clearly claimed at the end of the specification. However, a best understanding of the invention's organizational structure, operation, purpose, features, and advantages will be achieved by reading the following detailed description in conjunction with the accompanying drawings, wherein:

[0011] Figure 1 Example screenshots of the Gridshot (left subgraph) and Sixshot (right subgraph) tasks according to some implementation schemes are shown.

[0012] Figure 2 Example screenshots of the Adaptive Reflexshot task according to some implementation schemes are shown.

[0013] Figure 3 Example movement trajectories and model fittings based on some implementation schemes are shown.

[0014] Figure 4 This is an example illustration of the movement trajectory based on some implementation schemes, showing a short-range movement from point A to point B and an over-range movement from point C across point D.

[0015] Figure 5 Examples of movement parsing utilizing changes in movement direction are shown according to some implementation schemes.

[0016] Figure 6 Example distributions of motion kinematic performance metrics for Gridshot tasks (top row) and Sixshot tasks (bottom row) are shown according to some implementation schemes.

[0017] Figure 7 Examples of flick shot skill assessments based on some implementation schemes are shown, utilizing the time between target generation and the first shot being fired, as well as the shooting variability of the first shot fired.

[0018] Figure 8 This is a flowchart depicting a method according to an embodiment of the present invention.

[0019] Figure 9 A computer system according to an embodiment of the present invention is described.

[0020] Figure 10 A computer device according to an embodiment of the present invention is described.

[0021] Figure 11 Examples of speed-accuracy trade-offs and flick shot skill assessments using the Adaptive Reflexshot mission are shown according to some implementation schemes.

[0022] Figure 12 An example comparison of motion kinematic performance metrics for Gridshot and Sixshot is shown according to some implementation schemes.

[0023] Figure 13 Examples of correlations between individual differences in movement kinematic performance metrics and movement acuity are shown according to some implementation schemes.

[0024] It will be understood that, for the sake of simplicity and clarity, the elements shown in the accompanying drawings are not necessarily drawn to scale. For example, the dimensions of some elements may be exaggerated relative to others for clarity. Furthermore, where appropriate, reference numerals may be repeated in the drawings to indicate corresponding or similar elements. Detailed Implementation

[0025] Those skilled in the art will understand that embodiments of the invention may take different forms than the examples listed herein without departing from the spirit or essential characteristics of the invention. Therefore, the foregoing embodiments are to be considered illustrative in all respects and not limiting of the invention described herein. Consequently, the scope of the invention is defined by the appended claims rather than by the foregoing description.

[0026] In the following detailed description, numerous specific details are set forth in order to provide a thorough understanding of the invention. However, those skilled in the art will understand that the invention can be practiced without these specific details. In other instances, well-known methods, procedures, and components have not been described in detail so as not to obscure the invention. Certain features or elements described for one embodiment may be combined with features or elements described for other embodiments. For clarity, discussion of the same or similar features or elements may not be repeated.

[0027] While embodiments of the invention are not limited in this respect, discussions using terms such as “processing,” “calculation,” “operation,” “determine,” “establish,” “analyze,” and “check” can refer to one or more operations and / or one or more processes of a computer or other electronic computing device that manipulates and / or transforms data representing physical (e.g., electronic) quantities in the computer’s registers or memory into other data representing physical quantities similarly represented in the computer’s registers and / or memory or in other non-transient storage media that may store instructions to perform operations and / or processes.

[0028] introduction

[0029] The implementation scheme can evaluate video game input to measure esports player performance metrics (e.g., measuring an individual's flick-gun skill or kinematic agility based on flick-gun movement) and movement kinematic performance metrics. Player activities as described herein (e.g., flick-gun, firing) are typically provided as input to a computer system (the player typically views a computer-generated display). For example, player "movement" can refer to input provided by a user, such as using a game controller or computer mouse (e.g., input device 135 or 205), which causes some displayed representation of the user to move or causes a shift in the field of vision.

[0030] In some implementations, the orientation of the player's view of the environment, controlled by an input controller or device, is recorded in Euler angles and sampled, for example, at 120 Hz. Other sampling rates can be used instead of 120 Hz; one implementation uses a sampling rate range of 30-240 Hz. Besides Euler angles, other methods can be used to represent player orientation and movement, such as pixels or quaternions. In some implementations, game entities such as aiming markers or icons (e.g., crosshairs) can be marked with a dot at the center of the screen, corresponding to the direction in which the shot will be fired, and can be used to determine precision, accuracy, or error. In the virtual environment of the game, when triggered (e.g., when a user commands the system to fire a shot using an input device or controller), the shot can move along a straight line away from the player's avatar. The shot may then hit an entity such as a target, at which point the relative game or screen position of the aiming marker and the target can be used to determine the precision, error, or accuracy of the shot.

[0031] Some implementations utilize or obtain input from Aim Lab's products, such as Aim Lab's first-person shooter (FPS) evaluation and training games, to perform measurements using one or more games or gamified tasks involving shooting targets with multiple different target types (e.g., target sizes) and / or target presentation durations. Human performance is known to exhibit a speed-accuracy tradeoff. Different target sizes and presentation durations incentivize players to make faster but less accurate shots, or slower but more accurate shots. Some gamified tasks have adaptive features, such as dynamically adjusting target presentation duration and / or target size, which can prevent the evaluation process from experiencing a "ceiling effect."

[0032] Embodiments of the present invention can provide improvements over existing techniques used to assess motion agility or gaming performance. Existing methods for assessing player performance may be less effective than the methods of the embodiments of the present invention. One existing method for characterizing visual-motor performance is to apply Fitts' Law to a variety of tasks, including FPS tasks. Fitts' Law predicts that the time required to move quickly to a target is a function of the ratio between the distance to the target and the size of the target or the spatial error of the movement. As a complement to Fitts' Law, motion agility can be defined as the ability to perform actions more precisely in a shorter time. In one example, the application of Fitts' Law to FPS games is based on measuring the shooting time (e.g., the time elapsed from destroying a target to the first shot at the next target), target distance (e.g., the angular distance from the target when it first appears), and shooting spatial error (e.g., the angular distance between the shooting point and the target (e.g., the distance from the target boundary, the target center, etc.), or the target center) for two gamified tasks, each corresponding to one of two target sizes. Fitts' Law does not perform well in characterizing performance when considering both target sizes. In one example, shooting time, target distance, and shooting error are measured for each target. For each target, the logarithm of the ratio of target distance to firing error is calculated, and then grouped into decimals. For each group, 1) the median firing time is calculated; and 2) the median logarithm of the ratio of target distance to firing error is calculated. Fitts' Law characterizes performance well when fitted to data from each task separately (e.g., for each target size), but its characterization is extremely poor when combining two tasks (e.g., combining two target sizes). In other words, Fitts' Law predicts well the functional relationship between firing time and target distance and target error for each target size, but it is not applicable to combined data for two target sizes.

[0033] This failure of Fitts' Law may reflect differences in strategies between the two tasks; for example, players tend to use "swiping" more often against large targets than against small ones. Previous research has found a strong correlation between Fitts' Law and behavior in FPS tasks, but the participants in those studies were either amateur gamers or had not reported playing any FPS games at all. Swiping is an advanced technique typically used by highly competitive professional players when speed is critical.

[0034] Embodiments of the present invention provide a superior method for measuring competitive performance that separates skill from player strategy. Some embodiments may assess skill or agility as a relationship between speed metrics and variability or accuracy metrics. Each of speed and variability or accuracy may be measured based on player input such as: movement kinematics metrics (e.g., median movement speed, median movement landing error) or shooting performance metrics (e.g., median elapsed time to first shot, median first shot error). Typically, multiple data points are used to calculate speed and variability (and typically multiple data points for one target type are used to calculate speed, accuracy, variability, and / or precision). Accuracy may be 1 divided by variability.

[0035] Implementation schemes can measure performance metrics, such as motor agility in games, based on speed / accuracy or a speed / precision tradeoff. In some implementations, this is based on user input across multiple trials with several different target types or sizes, some of which may use the same target type—for example, 100 trials using two target sizes, with 50 trials using target size A and 50 using target size B. Some implementations evaluate players by having them complete two or more different tasks consecutively or within a short period (e.g., within the same day or hour, as player skill may vary over time), each task typically defined by a different target type or size. Each task may have different incentives regarding speed and accuracy. Implementation schemes can evaluate players individually (e.g., without comparison to other players) or by comparing them to other players. Implementation schemes can evaluate players by having them perform a game or gamified task using a first target type (e.g., a large target), then a game or gamified task using a second target type (e.g., a smaller target), and optionally repeating this process using other target types. Some implementations may interleave (e.g., randomly) different target types or sizes within a single game or gamified task. Some implementations may measure performance metrics (e.g., motion agility) by analyzing or plotting the relationship or tradeoff between speed and accuracy, variability, or precision in a task (e.g., by measuring the distance of a plotted speed-accuracy curve or function from the origin of the graph). Such a curve or function can represent the speed-accuracy tradeoff (SAT). Some implementations use statistical analysis to determine whether there are statistically significant changes or differences in speed and accuracy, variability, or precision, such as differences between players, changes over time (e.g., through practice or training), or the impact of various conditions (e.g., hardware, software, and multiple factors such as mouse, mousepad, rendering latency, posture, exercise, diet and supplements, sleep, etc.) on game performance.

[0036] Implementation schemes can determine motion agility or other performance metrics based on trade-offs or comparisons between performance metrics such as movement speed and movement variability, movement accuracy, or movement precision. In one implementation scheme, this can be done for multiple different target types or sizes: a player may perform a task more than once (e.g., the same task), each time for a different target type, or intersperse different target types within each round of the task. Statistical analysis or curve generation can be performed on data obtained with two or more target types to analyze speed / accuracy relationships or trade-offs, speed / precision relationships or trade-offs, or other relationships. (Some tasks may include only one target type; other tasks may intersperse different target types within the same task.) A curve, such as a SAT (Speed-Accuracy Trade-off) curve, can be generated: this curve can represent possible combinations of movement speed and movement accuracy given a player's skill level (typically measured based on a specific date or session, exhibiting temporal locality), with the player's current strategy determining where their current speed and accuracy are positioned on the curve. Implementation schemes can simultaneously measure speed and another performance metric (such as accuracy, variability, or precision); using a single performance metric as a proxy for motion agility may be less effective, as motion agility can be defined by both speed and accuracy. Furthermore, a straight line fitted to a player's movement speed and movement variability can be used to help the player adjust their strategy: if the slope is negative, close to zero, or close to vertical, it indicates that the player is not optimizing performance by balancing speed and precision across different situations (e.g., target type). In some implementation schemes, such analyses can be performed on multiple players to compare, rate, or rank player performance. Implementation schemes can use such statistical analyses or graphing to compare a player's ("newly observed" player's) performance with the performance of other players stored in a database; to compare the player's performance on different dates (e.g., to rate progress or regression, or to rate the player's performance over time).

[0037] The implementation plan can also determine motion acuity based on shooting performance metrics such as: rate of fire (e.g., 1 / median elapsed time between target appearance and the first shot toward each target) and shooting variability (e.g., variability of shooting position relative to the target or the center of the target), shooting accuracy, or shooting precision.

[0038] In one example, three different target sizes can be used: for example, small target size; medium target size; and large target size. Rate of fire (e.g., 1 / median elapsed time between target appearance and the first shot towards each target) and variability of fire (e.g., median angular error of fire, where the error of fire is the absolute value of the angle between the shot and the target or the center of the target) can be measured separately for each target size and individually for each player. For each player, a best-fit line can be determined that fits that player's rate of fire (e.g., in seconds). -1 The relationship between firing rate and firing accuracy (e.g., in degrees) data. The best-fit line may differ between players. Such a line can be redrawn as firing rate versus firing accuracy (in this case, 1 / firing variability, in degrees). -1 The resulting curve represents the transformation of the fitted straight line from each player. The diagonal dashed line extends from the origin (0, 0) to the point corresponding to the sum of the standard deviation (e.g., three times) of the distributions of shooting accuracy (x-axis) and shooting speed (y-axis) from all players. In some implementations, the intersection of the individual curves with the diagonal indicates the flick shot skill: the farther the intersection is from the origin, the higher the skill.

[0039] Players can make multiple moves and / or fire multiple times to destroy targets. Speed ​​can be measured as the median movement speed for each of the initial moves toward each target (e.g., the opposite of moves toward each target after the initial move). Variability can be measured as the variability of the landing point of the movement for each target (e.g., the opposite of moves toward each target after the initial move). Speed ​​can be measured as the rate of fire for each target's first shot (e.g., the opposite of shots after the first shot) (e.g., 1 / median elapsed time between target appearance and shot being fired). Variability can be measured as the variability of the first shot for each target (e.g., the opposite of shots after the first shot).

[0040] In some embodiments of the invention, the Flick Shot Skill Assessment (FSA) can be calculated as a performance metric that can be a robust and sensitive measure to assess and compare skills among players and to track the progress of a player’s skills over time as the player continues to train and practice.

[0041] Some implementation schemes characterize the fine-grained kinematics of player movement: speed, precision, accuracy, reaction time (SPAR), and swiminess (e.g., the tendency to shoot while moving rather than after landing on the target).

[0042] The implementation scheme for partially measuring motion acuity and kinematic performance indicators was validated by collecting and analyzing performance data from professional and amateur esports players. The results of this analysis revealed that: 1) kinematic characteristics depend on task requirements (e.g., for tasks that prioritize speed over accuracy, reaction time is shorter, while movement is less precise and more prone to "slide-shot"); 2) individual differences in motion acuity are highly correlated with motion efficiency (number of movements required to hit the target) and kinematics (reaction time, accuracy, and slide-shot tendency).

[0043] Embodiments of the present invention include, for example, methods for measuring and characterizing bouncy movement or other movements during an FPS game scenario. Bouncy movement can be planned and executed in advance without adjustment or reliance on sensory feedback, thereby achieving movement at the highest possible speed; this contrasts with certain human movements, which are typically performed at slower speeds and rely on sensory (such as visual or tactile) feedback for fine-tuning during movement.

[0044] Human performance (e.g., motor agility) exhibits a speed-accuracy tradeoff: the speed of a response or action is negatively correlated with the accuracy or precision of that action. People can be very fast but not very accurate, or very accurate but slow, or somewhere in between. This effect can be significant for different aspects of speed (e.g., reaction time, speed of movement) and different aspects of accuracy (e.g., percentage of correct responses / decisions, movement accuracy, and variability). A key characteristic of the speed-accuracy tradeoff is that humans can adjust their performance based on current demands and dynamically adjust the priority between speed and accuracy. If a task requires very fast responses or movement, a person may sacrifice accuracy to maximize speed. If the cost of an incorrect response is too high, a person may prolong response time or slow down movement speed to maximize accuracy.

[0045] In FPS performance, the speed-accuracy tradeoff or relationship can be characterized by movement kinematics performance metrics (e.g., reaction time to initiate movement, movement speed, movement accuracy, variability or precision across multiple movements). The speed-accuracy tradeoff can also be characterized by shooting performance metrics (e.g., the time interval between when a target appears and when the first shot is fired, and spatial error of the shot). Implementation schemes can use performance metrics calculated based on shooting performance. Some implementation schemes may include or evaluate movement kinematics performance metrics. Differences in flick-shooting skills between players of different skill levels, and between the same player learning, improving, or performing under different conditions, and the resulting position of the speed-accuracy tradeoff curve, will become apparent.

[0046] Performance on a single task with a single incentive for speed and accuracy may be insufficient to estimate a player's agility or FSA metric because the speed-accuracy tradeoff cannot be characterized by a single data point. It may be necessary to evaluate performance under multiple different conditions with varying priorities for speed and accuracy. Implementation methods can decouple an individual player's skill from the tradeoffs they make between speed and accuracy, and thus can represent skill differences and progress rather than biases or policy sensitivity measures.

[0047] Some implementations utilize products or systems such as the Aim Lab system, or those used in FPS video games. Aim Lab's system includes numerous tasks that replicate game scenes.

[0048] In addition to the typical flick-and-land movement, players sometimes opt for a tactic known as "slide-fire": maximizing speed by firing on the fly instead of decelerating before firing. With slide-fire, the endpoint of the movement may be far beyond the target location. Several implementation schemes characterize whether the movement is closer to typical slide-fire or typical flick-and-land movement. There exists a continuum of "slide-fire tendency," with ideal flick-and-land and ideal slide-fire corresponding to opposite ends of this continuum. In validating implementation schemes using the FSA metric, it was found that movement kinematics depend on mission requirements: for missions where speed is prioritized over accuracy, shorter reaction times result in lower movement accuracy and a greater "slide-fire tendency."

[0049] In one implementation, the FSA metric can improve assessment techniques by providing a highly sensitive and robust estimate of motor agility performance. Motor agility is the ability to perform actions more precisely and / or in a shorter time. Current research on motor agility is scarce, likely due to the severe resource constraints faced by laboratory research. A few laboratory studies have examined motor agility through relatively simple motor tasks, such as drawing a circle as quickly as possible within predefined boundaries, throwing a dart, or performing a center-outward grasping motion.

[0050] Embodiments of the present invention can evaluate performance based on data generated by players playing games or gamified missions (such as Aim Lab products (e.g., Sixshot missions, Gridshot missions, or Adaptive Reflexshot missions)); or other missions (such as missions specifically designed for healing). To develop an embodiment, motor learning was examined over a period of several months using a large sample of Aim Lab data (involving over 7,000 players and over 60,000 repetitions of the 60-second Gridshot mission). In this database, hits per second were used as a proxy metric for motor acuity. Embodiments of the present invention can alternatively use the FSA metric to measure motor acuity in FPS games.

[0051] The Aim Lab software system comprises commercial software products written in C# using the Unity game engine. Unity is a cross-platform video game engine used to develop digital games for computers, mobile devices, and game consoles. Players can download the Aim Lab system to, for example, their desktop computers, laptops, or PCs. While the AimLab system is one example of a system that can be used with embodiments of this invention, other systems may also be used.

[0052] Players can use input devices such as a mouse and keyboard or controllers to control their virtual weapons or other virtual tools in Aim Lab missions while watching the game on a computer screen. Performance data or measurements of user performance can be uploaded to Aim Lab's secure servers. The Aim Lab system includes a large number of different mission scenarios for skills assessment and training, each tailored to a specific aspect of FPS games. These mission scenarios can assess and train users in areas such as visual detection, motion control, tracking moving targets, auditory spatial localization, change detection, working memory capacity, cognitive control, distraction, and decision-making. Each mission can be customized to prioritize accuracy, speed, and other fundamental performance metrics. During a round, players are awarded points for each target they successfully shoot and destroy. In some missions, bonus points can be awarded for targets destroyed faster. Players attempt to maximize their score each round by destroying as many targets as possible. Different mission scenarios can incentivize players to prioritize accuracy over speed, or vice versa.

[0053] Player input can include manipulating input devices (e.g., mouse, Wii controller) to move the player character, or to move the player's aiming device (or weapon's aiming device), or the player's field of view; and also includes triggering or firing input to fire the device; and also includes input to move the player character in the game. For example, a user can move the mouse to change the player's aiming direction and click the mouse button to fire a weapon in the game. Measurements of speed, accuracy, precision, slip-fire tendency, etc., can be based on the relationship between game entities (e.g., targets, player's point of view (POV), weapon's aiming device), the movement of these entities (e.g., weapon's aiming device movement, target movement), and the timing of entity actions (e.g., weapon firing, target appearance, etc.). For example, the accuracy of a shot triggered by user input from a mouse or game controller can be determined by the aiming point (e.g., crosshair) relative to the point or position of the intended target at the time of firing. Users can move their avatars or players via keyboard input (e.g., known arrow keys or WASD input methods), which in turn can affect the game entities in the player's view, often perfectly aligning with the physical scope of the virtual weapon's crosshair or aiming point in FPS games. Players can use input devices to aim weapons, which typically means target localization, aiming, or rotating the POV, and can provide trigger input to the input device to fire the weapon. Other user input methods may also be used. Target localization, or the trajectory or movement of the aiming or crosshair, can be used to measure player movement kinematics metrics (e.g., movement speed, movement accuracy, movement precision, movement reaction time, or slip-fire tendency). The weapon's crosshair or aiming point position determines where the shot lands: for example, if the crosshair points to / is displayed above the center of the target when the shot is fired, the shot is identified as or considered to be centered on the target.

[0054] Some embodiments of the present invention utilize task scenarios for evaluating flick shot skills. A flick shot can be described as a sudden and rapid, jerky movement performed by a player in a game (including both sudden, rapid movements of the input device and movements on the screen), for example, to aim and fire a weapon to destroy (e.g., stationary or moving) a target. For example, embodiments utilize flick shot tasks with different target types (e.g., size and / or different target presentation durations) to characterize each player's speed-accuracy tradeoff and estimate their flick shot skills.

[0055] In some implementations, human participants or players remotely perform one or more FPS missions using their own game settings. Game settings may include, for example, hardware (such as a PC or other computer, monitor, mouse, and mousepad) and may be based on settings such as monitor size, field of view, viewing distance, chair height, or mouse count per inch (CPI) (e.g., stored in...). Figure 9The user operates on a user computer (or another computer). The equipment combinations between different players can vary widely. In some implementations, mouse acceleration is disabled. In other implementations, such as in a rehabilitation clinic, the task is performed on standardized hardware with standardized software settings.

[0056] In some implementations, movement trajectories (e.g., the movement trajectories of game entities, objects, or on-screen objects such as aiming points, weapons, etc.) can be determined by sampling the input position of an input device or controller controlled by the player during gameplay. The input controller can control multiple characteristics of the player, including, for example, the player's movement, the aiming of the player's weapon (e.g., indicated by a crosshair), and / or one or more actions of the player (e.g., the use of a weapon, such as firing a shot). Examples of input controllers used with some implementations include keyboards, mice, gaming mice, video game consoles, joysticks, accelerometers, gyroscopes, pointing devices, motion capture, Wii remotes, eye trackers, computer vision systems, absolute position headsets or six-DOF headsets (such as the Oculus Rift headset from Oculus VR), inside-out tracking headsets (such as the Quest six-DOF headset, which can track a person's gaze direction and the person's position in a room, for example using Lighthouse technology from HTC Vive and base station systems from Valve Index), or any methods, apparatus, devices, and systems for sensing, measuring, or estimating human movement to provide input signals to a computer. For example, a gyroscope in a smartphone or tablet computer can be used as an input device for games or gamified tasks running on these devices. Examples of human movement used with some implementations include hand movement, arm movement, head movement, body movement, and eye movement. Examples of input controllers also include brain-computer interface methods, apparatus, devices, and systems for sensing, measuring, or estimating brain activity. Examples of brain-computer interfaces include, but are not limited to, devices for measuring electrophysiological signals (e.g., using electroencephalography (EEG), magnetoencephalography (MEG), microelectrodes) and for measuring optical signals (e.g., using voltage-sensitive dyes, calcium indicators, intrinsic signals, functional near-infrared spectroscopy, etc.). Examples of brain-computer interfaces also include other neuroimaging techniques (e.g., functional magnetic resonance imaging). Examples of input controllers also include methods, devices, apparatuses, or systems for sensing, measuring, or estimating physiological data. Physiological data includes, but is not limited to, EEG, electrocardiogram (EKG), electromyography (EMG), electrooculogram (EOG), pupil size, and biomechanical data related to respiration and / or respiratory function. Those skilled in the art will recognize that any such input controller or any combination of such input controllers may be used. It is also recognized that other methods, devices, apparatuses, or systems for sensing, measuring, or estimating human movement or physiological activity may be used alternatively to those implementations, including those technologies that have not yet been practically applied.

[0057] Some implementations evaluate users or players (e.g., evaluating skills such as performance in a flick shot skill task) by engaging players in one or more games or gamified tasks or computer games (such as Gridshot, Sixshot, Adaptive Reflexshot, or other tasks) or providing them with input. Data collected from these tasks can be used to determine performance metrics in the relevant computer game tasks, such as collecting data on variability, accuracy, precision, and speed (e.g., time from target presentation to first shot) by presenting targets of various types (e.g., various sizes) in the relevant gamified task. Those skilled in the art will recognize that a variety of other tasks can be used as alternatives.

[0058] For example, Figure 1 Example screenshots of the Gridshot (left subgraph) and Sixshot (right subgraph) tasks according to some implementation schemes are depicted. Gridshot, Sixshot, and other tasks described herein can measure skills such as flick shot techniques. In implementations using the Gridshot task, several targets (e.g., three targets) are simultaneously presented (e.g., displayed on a monitor) at any given time, with a new target appearing after each target is destroyed. All targets can be of the same size, ranging from, for example, 1.3. ◦ Up to 1.7 ◦ (The range of viewing angles in degrees) is based on the range of viewing distances within the game's virtual environment (e.g., set by the player) and the range of values ​​for the field of view. The location of new targets can be randomized, for example, selected from 25 locations in a 5 × 5 grid, with a width ranging from 4.8... ◦ Up to 9.1 ◦ Between, the height range is 5.1 ◦ Up to 7.8 ◦The specific values ​​also depend on the viewing distance and field of view settings. Players aim by manipulating input devices or controllers (e.g., moving their mouse), such as moving the crosshair until it covers a portion of the target (preferably a central portion) and then clicking (e.g., the left mouse button) to shoot and destroy the target. Because multiple targets appear simultaneously, and there is no limit to the duration of target presentation and no explicit incentive to destroy any particular target, players must decide the order in which they destroy targets. Players receive immediate feedback when a target is destroyed: for example, an explosion sound, and the spherical target shatters into multiple fragments and then disappears. Players receive summary feedback after each, for example, 60-second round of Gridshot, including a score, hits per second (the number of targets successfully destroyed per second), and hit rate (the percentage of shooting attempts that successfully hit a target). Scores increase when a target is hit and decrease when a target is missed; the score is continuously displayed at the top of the screen throughout the game round. Performance metrics can be automatically calculated in the game's software (e.g., using Unity software development tools) and displayed to the player and sent to a secure server. The score gained for each target hit can be scaled based on the time elapsed since the last hit. In other words, the shorter the time since the last hit, the greater the score increase. Therefore, players are incentivized to shoot targets quickly and plan their next movement and shot rapidly. While players may be displayed with multiple performance metrics at the end of each round, they are likely to consciously optimize to increase their score. Performance metrics such as accuracy and speed can be calculated and collected for players and used to assess skill.

[0059] Performance metrics or data can be obtained from players using Sixshot missions (examples of which are in...). Figure 1 The process is collected during the process (as shown in the right sub-figure). The Sixshot mission is very similar to Gridshot, with the same possible target locations, but with the following differences: six targets are presented simultaneously each time, and the target size is approximately 14% of the size of the Gridshot target. The smaller target size requires higher shooting accuracy and precision.

[0060] Performance metrics or data can be collected as players perform tasks that present users with multiple target types (e.g., multiple sizes, target presentation durations, or other types) and adaptively adjust target size and / or presentation duration based on the player's performance at any given point in time. Adaptive Reflexshot (an example of which is...) Figure 2(See image) is an example of this type of task. Only one target appears randomly in a limited (e.g., oval) area in front of the player's virtual character at a time. The player must destroy each target within a time limit; otherwise, the target "times out" and disappears. If a target times out, the player receives no points for that target. To provide a visual cue for the remaining time, each target gradually becomes transparent and then disappears. This incentivizes the player to act as quickly as possible. Figure 2 The three subplots in the top row show time-series screenshots of the target gradually becoming transparent. Figure 2 The three sub-figures in the bottom row illustrate examples of three different target types or sizes. In some implementations, target presentation duration is dynamically adjusted based on performance: for example, reducing presentation duration in the next trial after a target is destroyed (the target becomes transparent more quickly), and increasing presentation duration in the next trial after a target times out (the target becomes transparent more slowly). In some implementations, target size varies between rounds of the task, and target presentation duration is dynamically adjusted separately for each target size. In some implementations, different target sizes are interspersed within each game round, and target presentation duration is dynamically adjusted separately for each target size. In other implementations, target size is dynamically adjusted within each game round: decreasing target size in the next trial after a target is destroyed; increasing target size in the next trial after a target times out. In some implementations, target presentation duration is constant within each round, but varies between rounds of the task, and target size is dynamically adjusted within each round. In some implementations, different target presentation durations are interspersed within each game round, and target size is dynamically adjusted separately for each target presentation duration. In some implementations, different target presentation durations and different target sizes are interspersed within each game round, and both target size and presentation duration are dynamically adjusted between trials based on whether the player destroys the target. In the implementation of the Adaptive Reflexshot task, players are incentivized to adjust their speed and accuracy according to target size and presentation duration in order to maximize their score.

[0061] Movement kinematic performance indicators

[0062] Some implementations can evaluate performance based on kinematic metrics such as movement range, movement speed, accuracy of movement landing point, variability or precision of movement landing point, reaction time between target appearance and movement initiation, and tendency to slide. In different implementations, various measures of movement speed, accuracy, variability, or precision, as well as other values ​​based on kinematics, can be used. Some implementations can analyze kinematic metrics and, for example, fit a parametric function to a time series of each player's movements.

[0063] Some implementations measure the kinematics of movement for each player for one or more tasks. A player's aiming at a target typically follows this process: initiating movement towards the target, accelerating, then decelerating, and firing after deceleration or near-total cessation. In some implementations, these kinematics of movement are characterized by fitting a sigmoid to a time series of movements. The best-fit parameter values ​​indicate or are measures of the following: movement accuracy (e.g., the amplitude of the sigmoid), movement speed (e.g., the slope of the sigmoid), movement precision (e.g., for multiple movements, 1 / (divided by) the median absolute difference between the sigmoid endpoint of the movement and the target (e.g., the center of the target, the edge of the target, etc.), and reaction time (e.g., the time at which the sigmoid movement is initiated).

[0064] For example, the player orientation (e.g., crosshair or weapon orientation) during each time period marked as "in motion" (e.g., through movement analysis) can be fitted using the sigmoidal function, for example:

[0065] (Equation 1)

[0066] (Equation 2)

[0067] (Equation 3)

[0068] Example Equation 1 defines the sigmoidal function. In this function, a, b, and c are the parameters of the sigmoid function, determining the lift point (indicating reaction time), slope (indicating velocity), and amplitude (indicating accuracy), respectively. The value of x(t) in Example Equation 2 represents the model of the horizontal component (rotation about the y-axis) of the trajectory for each time sample, where p1 becomes a, p3 becomes b, and p4 becomes c. The value of y(t) in Example Equation 3 represents the model of the vertical component (rotation about the x-axis) of the trajectory. Example illustrations of the model components x(t) and y(t) are shown in... Figure 3 As shown in the image. Figure 3 The top row shows two example movements in centimeters, calibrated using an input controller (in this example, a mouse). Figure 3 The bottom row shows two identical example movements scaled to normalized units so that 1 corresponds to the target position. Figure 3 The left column shows an example of flick shot positioning. The shot (vertical dashed line) occurs after the movement ends and the movement lands at the target position (horizontal dashed line). Figure 3The right column shows an example of a glide shot. The shot (vertical dashed line) occurs midway through the movement, and the landing point is far beyond the target position (horizontal dotted line). In this figure, the x-axis and y-axis time series of the mouse position in each trial are normalized, for example, by dividing by the x-component and y-component of the target position, respectively. The values ​​of parameters (p1, p2, p3, p4) can be fitted for each individual motion trajectory, for example, using the Levenberg-Marquardt algorithm. Figure 3 The circles in the image represent samples of the player's movement trajectory. Figure 3 The curves in the equations represent models of the motion trajectory, as shown by Equations 1, 2, and 3, employing the best-fit values ​​of the parameters. In Equations 2 and 3, the x and y components of the motion are fitted using shared parameters p3 and p4. In other implementations, the x and y components are fitted independently without using shared parameters, such that the midpoints and velocities of the x and y components can be different from each other.

[0069] Accuracy can be measured by how close a given set of measurements (observations or readings) is to their true values, while precision can be measured by how close the measurements are to each other. Precision can be a measure of a player's consistency in performance: for example, a player consistently landing shots at a certain distance from the target indicates precision, while shots landing sometimes close to the target and sometimes far from it indicates lower precision. On the other hand, accuracy can measure how close a player's shots are to hitting the target (e.g., average hit distance): systematically landing close to the target indicates high accuracy, while systematically landing shots far from the target indicates lower accuracy.

[0070] In some implementations, speed, accuracy, and reaction time can be calculated or measured based on the best-fit parameter values, for example:

[0071] 1. Speed ​​(e.g., cm / s or degrees / s): Peak speed at the midpoint of movement (the movement is, for example, the movement of a user-controlled game entity such as a weapon, aiming point, or crosshair).

[0072] 2. Accuracy (e.g., percentage of distance from the landing point to the target): This can be described as the distance between the landing point of the movement and the center of the target (e.g., spatial error). For example, if a 20-degree movement is required, but the player moves 18 degrees, the accuracy is -10% (10% off the target), while if the player moves 22 degrees, the accuracy is +10% (10% over the target). Distance can be measured in terms of, for example, angles, pixels, virtual distances that are meaningful in reality as displayed in the game, the actual distance from the input controller to the controller corresponding to the target (e.g., the mouse position on the mousepad), or other metrics.

[0073] 3. Reaction time (e.g., seconds): The time interval between when the target appears and when the movement begins (e.g., when the movement reaches 5% of its destination position).

[0074] The speed and accuracy of each parsed move or a set of parsed moves can be quantified, for example:

[0075] The player's position at time t (e.g., the position of the crosshair) is represented as x. t and y t The function f'(t) is the derivative of the sigmoidal function (Equation 6). m The value of a represents the magnitude of the movement (Equation 7) and a t The value represents the distance to the target position (Equation 8). Vector e represents the movement error (Equation 9), and vector u represents the unit vector in the direction of the target position (Equation 10). In some implementations, accuracy is calibrated to centimeters, and / or movement speed is calibrated to centimeters per second. In some implementations, accuracy is calibrated to degrees (e.g., the number of angles of rotation in a game's virtual environment), and / or movement speed is calibrated to degrees per second.

[0076] Other units and other methods of calculating speed, accuracy, and reaction time can also be used. Speed, accuracy, and reaction time can be measured based on multiple moves (e.g., by calculating the average or median of multiple moves).

[0077] Movement accuracy can be calculated as 1 divided by movement variability. Movement variability can be calculated as the standard deviation of the movement landing points (over multiple movements). Movement variability can alternatively be calculated as the median of the absolute values ​​of spatial errors (over multiple movements), such as the distance between the landing point and the center of the target. Variation can be expressed as a percentage of distance, and accuracy can be expressed as 1 / percentage of distance. Other measures of variability can be used instead of the standard deviation and median absolute error, and variability can be expressed in units other than percentages (e.g., degrees, centimeters).

[0078] To characterize "slide tendency," that is, how similar each jerky movement is to a slide (e.g., firing while moving) relative to a flick-fire positioning (e.g., decelerating and pausing before firing), some implementations compare the time of each shot to the time of the midpoint of the corresponding jerky movement. An ideal slide corresponds to firing at the midpoint of the movement (e.g., the point of maximum speed). An ideal flick-fire positioning corresponds to firing only after the movement has ended, after the midpoint of the movement. Some implementations calculate the slide tendency as the ratio of the firing time to the midpoint time (p4) divided by 2. This results in a "slide tendency" value of 0.5 (example arbitrary unit) for an ideal slide and a "slide tendency" value greater than or equal to 1 for an ideal flick-fire positioning. Other thresholds and other formulas may also be used. In these implementations, a slide tendency value is not calculated for movements without associated firing (e.g., if there is no firing between the start of one movement and the start of the next). Slide-fire tendency is a fine-grained measure of firing rate, related to movement trajectory. A lower slide-fire tendency indicates that the firing occurs earlier in the trajectory. Furthermore, no slide-fire tendency value indicates that movement and firing are unrelated. Moreover, in multiple trials within a specific environment or mission, the number of moves without a slide-fire tendency value reflects the number of moves the player needs to make to destroy any given target.

[0079] Shooting performance indicators

[0080] Implementation schemes can measure the speed, accuracy, or precision of shooting performance; other values ​​based on shooting performance may be used in different implementation schemes. Some implementation schemes operationalize or calculate speed and precision based on the first shot fired at each target. For example, speed can be calculated or based on the following metrics: 1) determining the elapsed time between target generation or appearance and the first shot being fired (e.g., input received from a game controller to fire the shot) for each target; 2) calculating the mean or median elapsed time of this generation to firing time for multiple targets; and 3) calculating 1 divided by the mean or median elapsed time. Similarly, precision can be calculated by the following steps: 1) calculating the shooting error of the first shot fired at each target (e.g., the distance between the point of impact of the shot in the game and the center of the target); 2) calculating the mean or median of the absolute values ​​of the shooting errors for multiple targets; and 3) calculating 1 divided by the mean or median shooting error. Other methods may also be used to calculate shooting speed, precision, or variability for multiple shots.

[0081] Distance can be measured while shooting. Shooting in progress can include input from the player to an input device such as a mouse or game controller, instructing the player to fire a virtual weapon (e.g., a rifle) at a target displayed in the game. The distance between the point of impact of the virtual shot in the game and the center of the target can be measured.

[0082] Error, accuracy and variability

[0083] Shooting performance or movement kinematics can be used to determine accuracy, variability, or other metrics. In some embodiments, accuracy or variability can be calculated using multiple metrics (typically errors) of shooting or (typically for a specific target type) movement kinematics. For example, multiple measurements of error for an indicator (e.g., shooting error or movement error) can be taken; variability can be calculated for that error; and accuracy can be determined as 1 / variability (therefore, variability can be 1 / accuracy). In some embodiments, error can be the absolute value of the error (e.g., the absolute value of the distance between the target center and the movement or shooting point), or other errors. In one embodiment, accuracy (e.g., shooting accuracy, movement accuracy) can be calculated as 1 / (divided by) variability or a metric based on 1 / (divided by) variability. Those skilled in the art will recognize that a variety of alternative methods exist for calculating shooting or movement variability. Some embodiments calculate shooting variability as the standard deviation of the shooting position or movement point, or the standard deviation of accuracy over multiple movements or shots. Instead, some implementations calculate the median absolute deviation (MAD) of metrics such as movement or shooting accuracy, or the median of the absolute difference from the median. MAD is a robust measure of variability and can minimize the impact of outliers.

[0084] Accuracy or other measurements can be based on multiple shots, movements, or trials by a single player, or multiple shots, movements, or trials by multiple players, for example, to compare a newly observed player with multiple other players in a database, or to compare a player with the past performance of the same player. Databases of speed, accuracy or variability, precision or error, reaction time, and other performance metrics can be created for players (e.g., past players) for comparison with new or future players.

[0085] Various measures of variability can be used instead of standard deviation or MAD. Some implementations calculate the square root of the median squared difference based on, for example, shooting accuracy or movement landing accuracy, or the median of the squared movement error, the square root of the median of the squared deviation, or other player metrics. Implementations calculate shooting variability based on shooting errors, such as the distance between each shooting position and the center of the target (rather than the mean or median of shooting positions). Implementations can calculate the mean, median, mean, or median of the movement or shooting errors for multiple shots or movements, the square root of the squared error, or the square root of the median of the squared error. Implementations can calculate movement variability based on movement errors, such as the distance between the landing point of each movement and the center of the target (rather than the mean or median of the landing points). Implementations can calculate the mean, median, square root of the mean of the squared movement error, and square root of the median of the squared movement error for multiple movements.

[0086] For tasks involving dynamically adjusting target size, some implementations operationally define variability and accuracy based on a target size threshold. The target size threshold can be calculated, for example, by the following steps: 1) determining the target size (e.g., pixels on a display; degrees of view; or another metric) and whether the target is hit for each target; 2) calculating the hit rate (the proportion of targets hit) for each possible target size; and 3) fitting a parametric function to the resulting hit rate. Some implementations use a maximum likelihood fitting procedure. Other methods for fitting psychometric data are well known to those skilled in the art. The target size threshold can alternatively be determined as the target size value that converges during dynamic adjustment. Accuracy can then be calculated as 1 divided by the size threshold.

[0087] Speed ​​measurement

[0088] The implementation scheme can use a variety of methods to calculate the rate of fire or kinematic metrics of movement. The implementation scheme can calculate or measure the speed based on, for example, the following: rate of fire (e.g., shots per second), hit rate (e.g., hits per second), number of movements per time interval (e.g., seconds), mean or median movement speed (e.g., in cm / s, degrees per second, pixels per second, etc.), the peak movement speed of a resolved movement or a set of resolved movements, the slope of a sigmoid describing the movement, the mean or median movement reaction time, the mean or median firing time (the time interval between target appearance and the first shot), or other metrics.

[0089] For task scenarios involving dynamically adjusted target presentation duration, some implementations operationally define velocity based on a target presentation duration threshold. The target presentation duration threshold can be calculated, for example, by the following steps: 1) determining the presentation duration and target hit rate for each target; 2) calculating the hit rate (e.g., the percentage of targets hit) for each possible presentation duration; and 3) fitting a parametric function to the resulting hit rate. Some implementations use a maximum likelihood fitting procedure. Other methods for fitting psychometric data are well-known to those skilled in the art. The target presentation duration threshold can also be determined as the target presentation duration value that converges during dynamic adjustment. The velocity can then be calculated as 1 divided by the presentation duration threshold.

[0090] In some implementations, velocity is operationally defined as 1 divided by a target presentation duration threshold (in such implementations, velocity can be a unitless metric). For an AdaptiveReflexshot task with multiple (e.g., three) different target types or sizes, the functional relationship between firing velocity (in example, 1 / second) and firing error (in example, degrees) can be analyzed comparatively. Firing velocity can be calculated, for example, based on a target presentation duration threshold; and firing error can be calculated, for example, based on the distance between the center of the target and the first shot fired at that target.

[0091] Move Analysis

[0092] Parsing or other processes can segment motion data into individual movements so that motion kinematics metrics such as speed, reaction time, and motion accuracy can be measured for each individual movement. A single movement can be defined from the user's input stream, for example, through parsing.

[0093] After the initial movement of the aiming point, the player, or the player's weapon towards the target, there is often a corrective movement. For example, the initial movement might be too large, thus exceeding the target, followed by a corrective movement in the opposite direction back towards the target (see [link to documentation]). Figure 4 Examples from C to D). Conversely, the initial movement can also be under-amplitude, i.e., failing to reach the target (see example C to D). Figure 4 Examples from A to B in the diagram illustrate this, thus requiring a corrective movement in the same direction as the initial movement. Sometimes there are multiple corrective movements. In some implementations, a single initial movement for each target can be identified as the movement with the largest magnitude in the direction of that target (e.g., within ±45 degrees). In some implementations, different types of movement components (initial movement and corrective movement) can be analyzed separately.

[0094] Some implementations analyze the time series of each player's movements, collected by an input device or controller. This analysis process takes multiple player inputs over a period of time as input and produces multiple well-defined movements as output. Movement can be recorded as a change in orientation (e.g., Euler angles) within the game's virtual environment. Movement analysis can label each point in time as, for example, in motion or stationary. After one or more consecutive samples exceed a velocity threshold, several time periods (e.g., time intervals corresponding to the sequence of consecutive time samples) are labeled as in motion. After one or more consecutive samples fall below the velocity threshold, several time periods are labeled as stationary. The number of consecutive samples used and the value of the threshold can be determined based on a large dataset including data from a large number of players. The duration of each consecutive time period (e.g., in motion or stationary period) may vary.

[0095] Players can change the direction of their movement without significantly slowing them down. For example, this might happen when multiple targets exist in a virtual environment; a player might initially move towards one target, then decide to prioritize another, without destroying or firing at the original target. Alternatively, a player might fail to reach a target in time, resulting in a bounce-like movement towards the target without firing. Some implementations utilize changes in movement direction to analyze movement. If a player moves in one direction and then changes to a significantly different direction, the time series can be segmented such that the period before the change in direction is associated with one movement, and the period after the change in direction is associated with another movement. Some implementations detect changes in direction when the angle of change in movement speed exceeds a threshold for one or more consecutive time samples. The number of consecutive samples and the value of the threshold can be determined based on a large dataset including data from a large number of players. Figure 5 An example is shown below. Player orientation is plotted in degrees. Figure 5 On the y-axis, time is distributed along the x-axis in seconds. Thick and thin lines indicate the x and y components of the player's orientation, respectively. The time intervals enclosed by black rectangles indicate time intervals where the player's movement speed is fast enough to be considered as being in motion. During the shown time intervals, the player moves in one direction and then rapidly changes direction without decelerating. The points of direction change are resolved as individual movements. Solid lines and curves correspond to the first movement in two movements. Dashed lines and curves correspond to the second movement in two movements.

[0096] In some implementations, performance metrics may include the median number of corrective moves required to hit a target, and the percentage of times a player hits a target in N actions (where N is a positive integer).

[0097] Some implementations associate each player movement with a single shot. Players typically make a series of movements to destroy a target. To associate a single shot with one or more movements, some implementations first identify the time when the shot was fired and then time backward (e.g., evaluate) from the time the shot was fired to identify movements initiated before that shot. Each shot can be associated with multiple movements. Each movement can be associated with multiple shots. For example, a player might fire a shot that misses a target during an initial slide movement, followed by a corrective movement and a shot that destroys the target. In this example, the initial slide movement could be associated with two shots. Some implementations associate movements with corresponding targets based on which shots are associated with the movement and which target(s) are closest to the associated one or more shots.

[0098] In some implementations, performance metrics may include the proportion of movement for unrelated shooting, which reflects the number of times a player needs to move to destroy any given target.

[0099] Input device calibration

[0100] Data analysis and validation can be performed in a wide variety of ways. For example, input controller or device calibration can be performed.

[0101] Some implementations measure the player's physical movement (e.g., the movement of the mouse on a mousepad when the input controller is a computer mouse). For this purpose, player orientation data, such as that depicted in a game (e.g., a crosshair), can be converted into a corresponding movement of the mouse on the mousepad, for example, in centimeters or inches (e.g., the actual physical movement used to generate player movement). This may require additional information about the relationship between physical mouse movement and changes in player orientation, which can vary from person to person due to differences in player hardware and software settings. Other input devices can be used.

[0102] Some implementations record in-game settings that control the field of view, as well as the sensitivity of the mouse or input device, such as the magnitude of camera rotation or field of view changes displayed to the user, caused by a single increment or count of mouse movement (which may determine aiming, crosshair, or weapon position). Mouse sensitivity in the x-axis and y-axis directions of movement can be recorded separately. Additionally, some implementations record the player's mouse settings (e.g., hardware, software, or both), which determine the counts (e.g., CPI, or counts per inch) generated per unit distance (e.g., per inch) of mouse movement.

[0103] In one implementation, for example, the player's camera orientation or aiming point (e.g., the position of the crosshair on the target) is converted into units of physical mouse movement (e.g., centimeters) according to a formula such as the following:

[0104] 1. Mouse sensitivity * 0.05 = Angular increment (degrees per count)

[0105] 2. Total rotation degrees / angular increment = count

[0106] 3. (Count / CPI) * 2.54 = Actual physical distance traveled (cm)

[0107] The value 0.05 is a sample constant used in the Unity software code to scale the mouse count to degree increments; other constants, formulas, and software tools can be used. In other implementations, similar methods and calculations can be used to calibrate the input controller, and the distance can be specified in metric units (e.g., centimeters), imperial units (e.g., inches), or other units.

[0108] Data post-processing

[0109] For example, data post-processing can be performed after data is obtained from a game, gamified task, or computer game, and, for example, before using said data to assess motion agility or flick shot skills. Some implementations apply one or more post-processing steps to motion kinematics metrics (such as speed, accuracy, precision, reaction time, and slip shot tendency) or shooting performance metrics to remove outliers and / or eliminate correlations between values. Some implementations apply upper and lower thresholds to remove outliers from motion kinematics metrics (e.g., assumed to be failures in trial analysis or sigmoid fitting). For example, the lower threshold could be 0 and the upper threshold could be the 95th percentile. In some implementations, if the sigmoid fit is poor (e.g., the coefficient of determination R-squared value is below 0.5), the corresponding motion data is pruned (e.g., not included in subsequent analysis).

[0110] In some implementations, each accuracy value is multiplied by 100 to convert the distance to the target from a ratio to a percentage. Some implementations subtract 100 from each accuracy value, resulting in negative values ​​for under-reach moves (moves that terminate before reaching the target) and positive values ​​for over-reach moves (moves that terminate after exceeding the target). For example, if using movement kinematics analysis, implementations can calculate the median of each kinematic metric across multiple moves for each player and for each move type (initial move and corrective move). This generates a total of 10 movement kinematic metric values ​​for each task: 5 kinematic metrics for the initial move (median speed, MAD accuracy, median precision, median reaction time, and median gliding tendency) and 5 kinematic metrics for the corrective move (median speed, MAD accuracy, median precision, median reaction time, and median gliding tendency). Some implementations calculate a z-score (a statistical measure of distance from the mean or average) for each player's movement kinematic metrics. Similar processing can be used for other player data, such as shooting performance metrics.

[0111] Figure 6 An example of the distribution of kinematic movement metrics for a dataset of 32 professional and semi-professional esports players, each of whom completed multiple rounds of Gridshot and Sixshot tasks, is shown. Once z-score standardization is performed (e.g., using standard deviation), some implementations test the kinematic movement metrics for normality (e.g., using the Kolmogorov-Smirnov statistical test). Figure 6 The annotation box in the figure shows the statistical results from the Kolmogorov-Smirnov test used for normality: D = KS-statistic and p = p-value; Figure 6 Other comment boxes indicate that the p-value is < 0.05. For Figure 6 The example distributions in the table show that the resulting p-values ​​indicate that most kinematic index distributions are non-normal (p < 0.05 for 6 out of 10 distributions). In such cases, nonparametric statistical analysis methods can be used, for example, to determine statistically significant differences in movement kinematics between players, between multiple groups of players, or over time.

[0112] Some implementations compare input controller sensitivity (e.g., mouse sensitivity) with motion kinematics metrics. To mitigate the confounding effects of input controller sensitivity (e.g., mouse sensitivity), some implementations regress the sensitivity values ​​to eliminate their influence. One implementation, for example, uses the Gridshot and Sixshot tasks, based on a dataset of 32 professional and semi-professional esports players, to perform a correlation analysis between mouse sensitivity and various motion kinematics metrics of the initial movement. The implementation can use statistical results from Spearman rank correlation (e.g., rho = Spearman correlation coefficient and p = p-value; for example, using p-value < 0.05).

[0113] One implementation can utilize the residual correlations after z-score standardization of each player's movement kinematics and regression analysis to remove the influence of mouse sensitivity from the kinematics. Mouse sensitivity may be correlated with movement reaction time, movement speed, glide tendency, and other performance metrics. This correlation can be eliminated through regression analysis. The implementation can use correlations to correct movement analysis before and after z-score standardization and regression analysis to remove the influence of mouse sensitivity.

[0114] An example regression operation consists of equations 11 through 13 in sequence. First, the pseudo-inverse 'a' of the mouse sensitivity array can be calculated. # This is then multiplied by the matrix Y of the kinematic index, which is standardized by the z-score, to obtain the estimated value x̂: Subsequently, the implementation can calculate the estimated value Ŷ by multiplying x̂ by the mouse sensitivity array A, which is normalized by the z-score: The residual (E) of the kinematic performance matrix is ​​obtained by subtracting Yˆ from y:

[0115] Adjustment of input evaluation

[0116] Some implementations can dynamically manipulate or adjust the evaluation or mapping of input signals from input devices, for example, for therapy or to train players to adjust the movement of their input devices accordingly. The relationship between input received from a player or patient via a controller or computer input device and the movement of virtual objects within the game's virtual environment can be changed, reset, modified, or adjusted based on performance metrics. For example, if a unit of mouse input will move an object or viewpoint on the screen by a second unit, the ratio of the second unit of movement to the first unit of movement can be changed based on performance metrics or motion acuity results. In one implementation, player performance is improved by training the player to make faster and / or more accurate movements using a motion adaptation scheme. In one implementation, the mapping from mouse position to screen position is dynamically adjusted during training or therapy. For example, if a player's movement to a specific target position is underweight, mouse movements toward the target at that position are remapped to make the movement more underweight. The player can then automatically learn to compensate for such changes, resulting in improved performance accuracy. Other implementations involve manipulating position, velocity, acceleration, or higher-order time derivatives of position acquired using one of the input controllers. Other implementations include manipulating orientation, angular velocity, angular acceleration, or higher-order time derivative of orientation acquired by one of the input controllers. Other implementations include manipulating joint angle, angular velocity of joint angle, angular acceleration of joint angle, or higher-order time derivative of joint angle acquired by one of the input controllers.

[0117] The relationship between manipulating controller inputs or human movement and their interaction with the virtual environment can be designed to improve human performance.

[0118] The relationship or mapping between the operator's movement and their interaction with the virtual environment or displayed objects may include manipulating at least one of the following: position, velocity, acceleration, higher-order time derivative of the position, orientation, angular velocity, angular acceleration, higher-order time derivative of the orientation, joint angle, angular velocity of the joint angle, angular acceleration of the joint angle, and higher-order time derivative of the joint angle.

[0119] Manipulating the relationship or mapping between input and on-screen movement can include setting or changing the sensitivity of the input controller (e.g., mouse sensitivity); this can be in response to performance metrics or, for example, to correct for deviations in player movement. In one example implementation, a player can make a series of movements from each of a plurality of starting positions to each of a plurality of target positions. For each movement, a positional error (e.g., the magnitude and direction of the difference between the landing position of the movement and the target position) is measured, and an average movement error is calculated for each combination of starting and target positions. The computer program then manipulates the sensitivity of the input controller to correct for systematic deviations in the player's movement.

[0120] In some implementations, various parameters of the input controller can be manipulated or adjusted, including, for example, the input controller's acceleration, different sensitivity parameters for different directions of movement, DPI (dots per inch, a measure of how many pixels an object moves on the screen for each unit of movement of the input controller), lift-off distance, polling rate, button response / debounce time, and angle adjustment. Relationships used to define the sensitivity of the computer input device or to define the number of dots per inch that a virtual object moves for each unit of movement of the computer input device can be adjusted. In one implementation, the input controller settings or sensitivity can be adjusted for certain directions of movement of the input controller. For example, sensitivity can be adjusted only for vertical, horizontal, left, up, down, or specific angles (e.g., when using a 360-degree orientation to define the measurement). Different sensitivity adjustments can be made separately for each of several different directions of movement. The parameterization of sensitivity can use parameters describing the direction of motion (e.g., degrees) to define different sensitivities for different directions.

[0121] The implementation scheme can utilize different performance metrics to determine the manipulation or adjustment of the relationship between input and movement on the screen, including, for example, scores, movement kinematics performance metrics, shooting performance metrics, motion acuity, or other player performance metrics.

[0122] Adjustments to sensitivity, mapping, or relationships can be made in software (e.g., in game software); or, for example, by adjusting input controller or mouse settings, or hardware settings.

[0123] Gun-flicking skill assessment

[0124] Performance (e.g., motion acuity) can be determined based on one of the speed performance metrics and one of the variability (or accuracy) performance metrics, and may optionally combine one or more pre-processing steps with post-processing steps. Implementation schemes may use a speed-accuracy tradeoff to measure flick shot skill assessment (FSA) or motion acuity. Statistical analysis or graphs can compare the functional relationship between rate of fire and median rate of fire variability, for example, for Gridshot and Sixshot tasks. One or more players being evaluated may follow expected behavioral patterns: lower accuracy and faster speed in Gridshot compared to Sixshot. This confirms that the player has made a strategic and appropriate response to the different demands of the two tasks. Multiple straight lines can be plotted, each connecting multiple (e.g., two) data points from the same player corresponding to multiple (e.g., two) tasks. After plotting or analysis, the resulting plot or analysis can be re-plotted or re-analyzed based on rate of fire accuracy (e.g., measured as 1 / or divided by rate of fire variability). The resulting curve can represent a transformed version of the straight line from the initial analysis or plotting. A diagonal dashed line or other plot can be drawn from the origin (0,0) to the coordinates corresponding to three times the standard deviation plus the mean of the distributions of shooting accuracy (x-axis) and shooting speed (y-axis) for all players. In some implementations, the intersection of each curve with the diagonal can indicate flicking skill. Some implementations obtain a flicking skill value for a player by identifying the point along the diagonal that intersects with the player's speed-accuracy tradeoff curve; in some implementations, arbitrary skill units can be assigned to the relative position of the intersection point or the distance between the intersection point and the origin. This relative skill can be a comparison between the player and other(s) players(s); or it can be a comparison between the player and their own performance at another point in time. A speed-accuracy tradeoff curve pointing to the upper right indicates better performance, such as higher accuracy and faster speed. It is worth noting that, as demonstrated elsewhere in this document, these flicking skill values ​​are related to certain aspects of movement kinematics; movement kinematics can provide underlying details of specific differences in skill between players. By plotting a diagonal line through each player's speed-accuracy tradeoff curve, players can be ranked; for example, a speed-accuracy tradeoff curve further from the origin corresponds to a player with higher measured skill. Such implementations can compare motion acuity values ​​among players to determine which player has superior skill; or characterize a player's progress over time (for an individual player); or analyze groups or individual players under different conditions (e.g., hardware, software, and various other factors such as mouse, mousepad, rendering latency, posture, exercise, diet and supplements, sleep, etc.) to determine the impact of these factors on performance (e.g., proving a new gaming mouse is better than competitors).

[0125] In one implementation, FSA is calculated as a value along a diagonal or other plot or line intersecting the player's speed-accuracy tradeoff curve. There are various methods for calculating this flick-shooting skill value. For example, in one implementation, the diagonal is transformed back into a speed-of-fire versus accuracy graph, and the intersection point can be found within that graph; the diagonal can be a scoring scale line indicating the skill. In one implementation, a mathematical formula is used to find the intersection point. In other implementations, straight lines with different slopes are used, or the x-axis and / or y-axis are rescaled.

[0126] Figure 7 Examples of FSA (Fire-Standard Action) for multiple targets, utilizing the time between target generation and the initial firing, and the firing variability of the initial firing, are shown according to some implementation schemes. Figure 7 In this diagram, the Y-axis represents velocity, and the X-axis represents variability and accuracy, respectively. In another implementation, a diagram similar to... Figure 7 The curves on the right represent the relationship or comparison between speed and accuracy for different target types or sizes. Figure 7 The analysis included firing rate and firing variability, but regarding... Figure 7 The described methods can be used for other performance metrics such as movement kinematics. Typically, speed, variability, and accuracy are similar types of performance metrics: for example, shooting performance metrics (such as in...) Figure 7 In some implementations, speed can be the primary metric (e.g., rate of fire), and both variability and accuracy can be another metric (e.g., movement accuracy). Some implementations define the axis of performance or flick shot skill as a straight line from the origin (0,0) to the coordinate point corresponding to a specific multiple (e.g., three times) of the standard deviation of the distribution of accuracy (x-axis) and speed (y-axis) for all players, plus the mean. Figure 7 An example of a speed-accuracy tradeoff curve for three players (other numbers of players can also be used) is shown, and Figure 7 The dashed line on the right illustrates an example of the flicking gun axis. In some implementations, the intersections of the curves with the diagonal (which could be a performance rating scale) indicate flicking gun skill. Figure 7 In the example, players represented by diamond-shaped dots have the best flick-shooting skills, while those represented by circular dots have the worst. In other implementations, alternative axes exist for defining flick-shooting skills.

[0127] Typically, for each individual data point (e.g., shooting, movement, etc.), its variability is determined by multiple error measurements within a single session (e.g., a match or a gamification test) (e.g., based on standard deviation or other calculations), and a data point or data plot is created for a single player within that test, match, or other time period (e.g., ...). Figure 7 The variability is represented by one of the rhombuses, shapes, or squares in the left-hand chart. Typically, each point represented by a certain shape is used for a specific target type (e.g., size), and straight lines are drawn by connecting points of different target types. Straight lines are drawn for each player and each session, and a reverse plot is created based on these lines to demonstrate accuracy, such as... Figure 7 As shown on the right. In some implementations, for one or more players providing input to the game or gamified task, for each player's at least two target types or sizes, speeds (e.g., rate of fire, speed of movement, etc.) can be analyzed or plotted relative to variability (e.g., shooting variability, movement variability, etc.) (e.g., using statistical analysis). In one implementation, a database is created for historical performance data of many players. For example, data on speed, accuracy, variability, precision, etc., could be collected for each of thousands of movements and shots.

[0128] For example, a straight line (e.g., a best-fit line) can be drawn for each player through multiple target type points, thus generating a straight line for each player. Figure 7 The left subplot illustrates the functional relationship or correlation between rate of fire (in 1 / s) and rate of fire variability (in degrees) in the Adaptive Reflexshot mission, involving three different target sizes and three different players. Rate of fire can be calculated as the median elapsed time between the time sample of target spawn and the time interval between the first shot fired at that target. Rate of fire variability can be calculated as the median distance between the target center of multiple targets and the first shot fired at that target. For each player, Figure 7 The leftmost player symbol in the left-hand graph represents a point for small target sizes, the next player symbol to the right along the X-axis indicates a medium target size, and the rightmost player symbol represents a point for large target sizes larger than the two symbols to the left (in this example, each player is evaluated based on three target types or sizes). While three different sizes are shown, other implementations may use other numbers greater than one. Each straight line in the left graph is the best-fit line from a player's data (e.g., rate of fire related to the player or the variability of the player's input).

[0129] Figure 7 The right sub-map is based on shooting accuracy (e.g., in degrees). -1These results are redrawn for 1 / shot variability, thus transforming or converting each straight line on the left into a curve on the right. The curve represents the result of the transformed straight line from the left subplot, showing the relationship or comparison between speed and accuracy for each player (e.g., the relationship between shot speed and shot accuracy). Figure 7 In the example, the imaginary diagonal indicates the axis of the flick shot skill, and the intersections of the curves with the imaginary diagonal indicate the Flick Shot Skill Assessment (FSA), a measure of performance or agility in flick shot tasks. For example, for player X, the greater the distance of the curve from the origin, or the greater the distance of its intersection with the straight line from the origin, the better the player's assessed skill, performance, or agility. The diagonal can be a tool or ruler used to standardize the distance of the curve from the origin. In some implementations, past players' speed and accuracy data can be plotted in this way into a database, and the relative skill level of new players can be assessed by comparing the speed-accuracy tradeoff curves and flick shot skills of newly observed players with the data of past players. In some implementations, a numerical rating scale can be defined for flick shot skills, such that, for example, players with average skill levels are assigned an FSA value of 100, players who are one standard deviation above the average are assigned an FSA value of 110, players who are two standard deviations above the average are assigned an FSA value of 120, players who are one standard deviation below the average are assigned an FSA value of 90, and so on.

[0130] Some implementations can rank the flick shot skills of multiple players, or rank the changes in the flick shot skills of an individual player over time, for example, by making the intersection of the speed and accuracy curves with the flick shot skill axis (dashed diagonal) more to the upper right as the player improves over time (e.g., due to the increase in speed and accuracy).

[0131] In some implementations, the flick shot skill axis (e.g., indicated as) Figure 7 The diagonal dashed line (in the diagram) extends from the origin (0, 0) to the coordinates corresponding to three standard deviations plus the mean of the distributions of accuracy (x-axis) and speed (y-axis) for all players. Any suitable measure of central tendency and dispersion can be used. Any suitable dispersion factor can be used instead of the value three, and the factors for the x-axis and y-axis can be different from each other. In other implementations, the axis of the flick shot skill can be defined as passing through the mean of the speed and accuracy values ​​and extending to a range of plus or minus three standard deviations. Similarly, any measure of central tendency (e.g., median) can replace the mean, any measure of dispersion can replace the standard deviation (e.g., MAD), and any dispersion factor can be used instead of three standard deviations.

[0132] In some implementations, it is not necessary to generate Figure 7Instead of the chart shown, statistical analyses similar to those shown can be performed, for example, to determine the relative distance of a line along a player's performance curve from the origin. In other embodiments, statistical analyses can be performed on the player's speed and accuracy (e.g., the relationship between speed and accuracy).

[0133] The implementation plan can perform multiple linear regression (e.g., for multiple data points, each corresponding to a summation of speed values ​​related to precision, accuracy, or variability (e.g., mean or median)). Statistical analysis can determine whether there is a change in performance or motor agility, such as whether there is a substantial improvement in speed (e.g., greater than 5%) while there is no substantial change in variability, precision, or accuracy (e.g., no greater than 5%), or a substantial improvement in variability, precision, or accuracy (e.g., greater than 5%) while there is no substantial change in speed (e.g., less than 5%), or a substantial improvement in both speed and accuracy (e.g., greater than 5%). Other measures or thresholds can be used to define or define changes in motor agility; for example, a change in motor agility can be determined if there is a speed improvement of >10% without a substantial change in variability, or other combinations of changes with different thresholds. Statistical hypothesis testing can be used to determine one or more values ​​for judging whether there is a substantial change in speed and / or variability, precision, or accuracy, to determine whether there is a statistically significant change in motor acuity. For example, if there is a statistically significant increase in speed without statistically significant evidence for changes in variability, precision, or accuracy; or if there is a statistically significant increase in precision (or variability or accuracy) without statistically significant evidence for changes in speed; or if there are statistically significant increases in both speed and precision (or variability or accuracy). Such implementations can determine whether differences in motor acuity exist between different players, under different conditions, or over time.

[0134] In some implementations, performance metrics other than accuracy (e.g., the accuracy or variability of a player's movement or input to the game) can be compared to speed or their relationship to speed can be analyzed. The accuracy, variability, or other measures of the speed-related player being analyzed can be, for example, a player movement kinematics performance metric, a shooting performance metric, or the accuracy, variability, or other measures of another player's performance metric. Other measures of player speed can be used, such as movement speed, shooting speed, or other variations of speed measures, including target presentation duration thresholds as discussed elsewhere herein. Implementations use accuracy as a performance metric, and measures of accuracy, such as movement accuracy, shooting accuracy, or other measures, can be used. In one implementation, comparing the movement acuity of two players (or comparing the same player's movement over time) includes statistical analysis to determine whether speed increases (for a single player) or is greater (comparing different players) over time, and there is no statistically significant evidence that accuracy has changed (and vice versa).

[0135] In some implementations, movement speed or movement variability (e.g., parsing as described herein) can be used as a measure instead of firing speed or firing variability because in some FPS tasks, player movement has a landing point or endpoint. For some applications, firing may not be present—for example, a task where a player or user aims at the center of a target (e.g., moving the crosshair to the middle of a circle) without clicking or firing input—but movement can still be a measure in applications where firing is present. In some FPS tasks, flicking can involve moving, stopping movement, and firing; while sliding can include firing while moving, and in some of these tasks, movement itself can be a measure of skill. Speed ​​can be, for example, the speed at which a trigger is pulled, or the peak or average speed of movement, such as mouse movement, movement on a mousepad, rotational angle movement, etc.

[0136] Some implementations test the normality of flick shot skill values, and some implementations use non-parametric methods for statistical analysis, for example, to determine statistically significant differences in flick shot skills between players, between multiple groups of players, or over time.

[0137] Some implementations compare input controller sensitivity (e.g., mouse sensitivity) to flick-shot skill values. To mitigate the confounding effects of input controller sensitivity (e.g., mouse sensitivity), some implementations remove the influence of sensitivity from flick-shot skill values ​​through regression. In one example validation, or this one, the correlation between mouse sensitivity and flick-shot skill was analyzed for 32 professional and semi-professional esports players. After z-score normalization of flick-shot skill values ​​among players and removing the influence of mouse sensitivity from flick-shot skill values ​​through regression, residual correlation analysis was performed. In this example, mouse sensitivity was correlated with flick-shot skill, and this correlation was removed by regression procedures. Statistical analysis was performed using Spearman rank correlation: rho = Spearman correlation coefficient and p = p-value; the example p-value is < 0.05.

[0138] Figure 8 This is a flowchart depicting a method according to an embodiment of the present invention. Figure 8 The operation can be used as follows Figure 9 and / or Figure 10 It can be executed using the hardware system in the document, but it can also be executed using other hardware systems.

[0139] In operation 400, data can be collected from players, such as when players provide input to the game or gamified tasks. For example, data from multiple players (such as movement data, shooting data, speed data, accuracy data, or other data) can be collected to create a database or a collection of player performance metrics. Such data storage can be used to compare newly observed players with other players. For example, in an implementation that determines a user's progress over time, data from a single player to be evaluated can be collected. In one implementation, the data collected for each player involves more than one type of objective.

[0140] In operation 410, a player (e.g., a newly observed player or a player who has previously provided input) can provide input to the game or gamified task.

[0141] In operation 420, the performance or motion acuity of a newly observed player relative to (e.g., as collected in operation 400) a group of other players or the same player at an earlier time can be calculated, evaluated, or determined. This can be performed, for example, by determining one of the player's (e.g., shooting or moving) speed and the player's (e.g., shooting or moving) accuracy, precision, and variability for multiple different target types (e.g., different target sizes), and determining motion acuity or flick shot skill based on the relationship between the player's speed and said one of the player's accuracy, precision, and variability. This analysis can be performed, for example, by statistical analysis, graphing, statistical analogy of graphs, or other methods as described herein. Performance can be calculated by, for example, the following steps: determining a straight line (e.g., a best-fit line) corresponding to or fitted to the plot points of the player speed-variability relationship for multiple target types (e.g., different plot points for each target size); converting said straight line into a curve (e.g., drawing a curve using the inverse of one of the parameters of said straight line); and calculating performance based on the position of said curve in the graph (e.g., the distance of the curve from the origin of the graph or other points).

[0142] In operation 430, an evaluation can be output. Evaluations can be used, for example, to compare multiple players to determine which player has better skill, or to compare individual players over time to characterize that player's progress over time. For example, comparisons can be used to determine the impact of device factors on performance (e.g., proving that a new gaming mouse is better than competitors). Some implementations maintain a database of players and their flick shot skill evaluation scores, notifying the player when they reach a specific ranking compared to other players (e.g., ranking in the top 10%). Some implementations display a leaderboard of top (e.g., top 100) players with the highest flick shot skill evaluation scores. Some implementations report the flick shot skill evaluation rankings of multiple players to esports organizations, leagues, team owners, and coaches.

[0143] Other operations or series of operations can be used.

[0144] Other metrics of performance or motion acuity can be used. For input controllers that sense or measure physical movement (e.g., mouse, keyboard, eye tracker, motion capture, etc.), various methods exist for quantifying the accuracy of a player's movements. Input controllers can sense, measure, or estimate human movement and provide input signals to a computer to interact with a virtual environment. For example, input signals can alter the 2D or 3D position and orientation of a virtual character or other on-screen object being controlled by the player, or the 2D or 3D position and orientation of a virtual object in the game's virtual environment. In one implementation, the input signal controls a cursor rendered on a computer monitor. The accuracy of the player's movements can be quantified based on physical movement in the real environment (e.g., the position or relative position of the mouse) or on virtual movement in the virtual environment (e.g., the position of a cursor controlled by the mouse). For example, the 2D screen position of the cursor on the computer monitor can be compared to a 2D projection of the 3D position of an object in the virtual environment. To do this, the computer converts the 3D position in the virtual environment into a corresponding 2D screen position, which is a projection of that 3D position. In another embodiment, accuracy can be quantified based on the 2D or 3D position and orientation of virtual objects in the virtual environment. Human movement typically involves multiple distinct phases. In one embodiment, the accuracy of the initial movement can be quantified. In another embodiment, the accuracy of the final endpoint after one or more corrective movements can be quantified along with the original movement. In another embodiment, the accuracy of each component movement can be quantified. The accuracy of a single movement can be quantified as the error between the performed movement and the desired movement, for example, the difference between the endpoint of a cursor movement and the position of a target on a computer monitor. Accuracy can include the magnitude and / or direction of the error. In one embodiment, the distribution of such errors can be measured and characterized. The distribution of errors can be characterized by calculating statistical measures based on multiple such errors. Statistical measures that can be calculated include mean, median, mode, variance, covariance, skewness, kurtosis, and higher-order statistical moments. In another embodiment, the distribution of errors can be characterized by fitting a model to multiple such errors. The distribution of errors can be fitted using a statistical model (e.g., a multivariate normal distribution). In another implementation, the distribution of errors can be fitted using a functional model (e.g., a model of the neural processing controlling eye movement or body movement). It is also recognized that various statistical or functional models can be employed as alternatives, including those not yet practically applied. Accuracy can be measured individually for each target or aggregated across targets (e.g., by taking an average).

[0145] Manipulation of the result of player input, or alteration of the mapping or relationship with the input device, may include manipulating at least one of the following player inputs: position, velocity, acceleration, higher-order time derivative of the position, orientation, angular velocity, angular acceleration, higher-order time derivative of the orientation, joint angle, angular velocity of the joint angle, angular acceleration of the joint angle, and higher-order time derivative of the joint angle.

[0146] Figure 9 A computer system according to an embodiment of the present invention is depicted. The embodiment may include one or more computer systems that execute software to perform the methods discussed herein. For example, user computer 200 may be, for example, receiving input from a user (e.g., a gamer) via an input device 205 (e.g., a mouse, Wii controller, iPad, etc.) to a video or computer game 210, and on a computer monitor or such... Figure 10 The game output (e.g., such as) is displayed on the monitor of the output device 140. Figure 1 and Figure 2 The user computer 210 (as shown in the view) is a desktop computer, laptop computer, personal computer (PC), cellular phone, smartphone, or game console or computer (e.g., Xbox, PlayStation, etc.). The game 210 and its user interface can be displayed via or in conjunction with other software (such as an internet browser, Steam game distribution service, or other software). The game 210 can be executed wholly or partially on computer 200 and / or a remote computer such as server 300, which may be a computer operated, for example, by a game or gamification task provider company (e.g., State Space Labs), cloud computing facilities, etc. Computer 200 can provide output such as a game display and can be connected to other computers such as server 300, for example, via one or more networks such as the Internet 290. User computer 200 and / or server 300 can assess the player's performance or skills, provide training, provide treatment, or provide other methods as discussed herein. User computer 200, server 300, and other systems may include, for example, system 100 (… Figure 10 The computer's components in ).

[0147] In some implementations, human participants or players remotely (e.g., from a server 300 providing the game) provide input to a movement task (e.g., moving to the center of a circle) or other task (e.g., gamified task, training, therapy, etc.) using their own game settings (such as user computer 200). The game settings, such as computer 200, may include hardware such as: a PC, a monitor (e.g., ... Figure 10 The monitor 140), input device 205 (e.g., Figure 10 The input device 135 and mouse pad can be used, and can operate based on settings such as monitor size, field of view, viewing distance, chair height, or mouse count per inch (CPI), for example, stored on computer 200 or server 300. Some implementations work with or receive input from products from Aim Lab, such as Aim Lab's first-person shooter (FPS) evaluation and training games. For example, server 300 can execute Aim Lab products such as Sixshot or Gridshot missions, or games such as Fortnight or Counter-Strike: Global Offensive (CS:GO) video games, and / or user computer 200 can download and execute such missions without processing on a remote server. Such missions or games can interact with server 300 via internet connection 290 when executed. Analysis or creation of performance metrics such as FSA can be performed by user computer 200, server 300, or other systems. Players can participate in such tasks (e.g., provide input to them), and the tasks can generate data (e.g., events, mouse or game controller movements, movement speed, movement precision, accuracy, other movement data, etc.), and this data can be used by, for example, user computer 200 and / or server 300 to generate motion acuity, player performance, performance metrics, skill level, etc.

[0148] Figure 9 The system can be a handheld device, such as a medical device. Such a handheld medical device, or a device that includes a game or other controller, can be used to perform sensorimotor and cognitive assessments and / or treatments of a patient using the methods described herein.

[0149] Although a user computer 200 and a server 300 are shown, other implementations may use multiple such computers connected, for example, via a network such as the Internet 290.

[0150] Figure 10 A computer device according to an embodiment of the present invention is depicted. The computing device 100 may include (for example, a central processing unit processor (CPU), a chip, or any suitable computing device) a controller or computer processor 105, an operating system 115, a memory 120, a storage device 130, an input device 135, and an output device 140 (such as a computer display or monitor showing, for example, a computer desktop system). The various embodiments and operations discussed herein can be performed by one or more computing devices such as the computing device 100.

[0151] Operating system 115 may be or may include code for performing tasks involving coordination, scheduling, arbitration, or management of the operations of computing device 100 (e.g., execution of a scheduler). Memory 120 may be or may include, for example, random access memory (RAM), read-only memory (ROM), flash memory, volatile or non-volatile memory, or other suitable memory units or storage device units. Memory 120 may be or may include multiple different memory units. Memory 120 may store, for example, instructions (e.g., code 125) for performing methods as disclosed herein and / or data such as documents.

[0152] Executable code 125 can be any application, program, process, task, or script. Executable code 125 can be executed by controller 105, which may be under the control of operating system 115. For example, executable code 125 can be one or more applications performing methods as disclosed herein. In some embodiments, multiple computing devices 100 or multiple components of device 100 may be used. One or more processors 105 may be configured to perform embodiments of the invention by, for example, executing software or code.

[0153] Input device 135 may be or may include a game controller (e.g., a Wii controller), a gyroscope sensor, an EEG sensor, an EMG sensor, a mouse, a keyboard, a desktop computing device, a touchscreen or pad, or any suitable input device or combination thereof. Output device 140 may include one or more displays, speakers, and / or any other suitable output device or combination thereof. Any suitable input / output (I / O) device may be connected to computing device 100; for example, a wired or wireless network interface card (NIC), a modem, a printer, a universal serial bus (USB) device, or an external hard drive may be included in input device 135 and / or output device 140.

[0154] Embodiments of the present invention may include one or more items (e.g., memory 120 or storage device 130) that encode, include, or store instructions (e.g., computer-executable instructions), such as a computer or processor non-transient readable medium, or a computer or processor non-transient storage medium (e.g., a memory, a disk drive, or a USB flash drive), which, when executed by a processor or controller, perform the methods disclosed herein.

[0155] Some implementations assess the dexterity with which players can adjust their performance in response to mission requirements. In FPS games, opponents can appear at a distance (e.g., rendered as a small target on the player's screen) or nearby (e.g., rendered as a large target on the player's screen). Skilled players can flexibly adjust their operational strategies along their SAT function or line based on such situations, prioritizing speed against nearby opponents (e.g., large targets) and accuracy against distant opponents (e.g., small targets). Some implementations compare performance in two scenarios: one where different target sizes are presented in different game rounds, and another where different target sizes are interspersed within each game round. Ideal players will perform identically in both scenarios (single rounds vs. interspersed rounds). However, when different target sizes are interspersed, most players will show a decline in performance (e.g., flick shots and / or movement kinematics) because this version of the mission has the additional requirement that players must make the optimal trade-off between speed and accuracy for each target. Therefore, by comparing a player's performance when playing with different target sizes in different rounds versus when playing with different target sizes interspersed, the ability of players to optimize the tradeoff between speed and accuracy is characterized, thereby improving performance evaluation techniques. The FSA ratio when different target sizes are interspersed versus when different target sizes are used separately in different rounds can be used as a measure of a player's ability to optimize the tradeoff between speed and accuracy. Some implementations maintain a database of players and their FSA ratios. Some implementations notify players when they obtain a characteristic ranking of their FSA ratio compared to other players (e.g., top 10 percentile), or display a leaderboard of players with the highest FSA ratios (e.g., top 100), or report the FSA ratios to esports organizations, leagues, team owners, and coaches. Any comparison of FSA when different target sizes are interspersed versus when different target sizes appear in individual rounds can be used as a substitute for the FSA ratio.

[0156] Some implementation schemes include training programs in which individuals participate in multiple training sessions spanning several days. During a single training session, the individual performs multiple repetitions of various tasks, each of which includes targets of different sizes and / or presentation durations. Performance in each session is evaluated using flicking skills and / or movement kinematics. Any changes or progress in FSA can be presented to the player as charts or other visual representations.

[0157] In some implementations, FSA is used to assess the impact of hardware, software, and various other factors (e.g., mouse, mousepad, rendering latency, posture, exercise, diet and supplements, sleep, etc.) on performance. Implementations compare the FSA of one or more players under different conditions, thereby providing practically relevant insights into these factors, such as helping to choose which mouse or mousepad (or other hardware) to purchase, or providing recommendations on exercise, diet, and sleep to optimize performance.

[0158] Some implementation schemes can improve rehabilitation techniques and may include gamified rehabilitation for patients recovering from, for example, stroke, traumatic brain injury, cerebral palsy, or arm injury, or receiving treatment for such injuries. These implementation schemes can measure progress in motor acuity over time. Some implementation schemes can improve concussion assessment by comparing an individual's performance to a baseline measured prior to an event that may have caused the injury to determine if the individual is likely to have suffered a concussion or brain injury. Some implementation schemes include assessments to determine whether an athlete should return to competition after a concussion. Some implementation schemes include assessments and training for individuals learning to use prostheses. Some implementation schemes include assessments and training for stroke rehabilitation. Some implementation schemes include assessments and training for patients with mobility impairments (e.g., cerebral palsy). Implementation schemes can maintain a database of patients and their motor acuity scores over time, which can be displayed to patients as graphics or some other visual rendering. Implementation schemes can provide clinicians with dashboards to track their patients' progress and support decision-making, such as which interventions might be most effective or appropriate, and decisions about whether an athlete should withdraw or be allowed to compete.

[0159] The embodiments of this invention (e.g., using FSA) can provide a measure of motor acuity independent of strategy and SAT over short time periods without upper or lower bound effects, enabling improvements over existing technologies and tools in a wide range of basic and applied research and therapeutic areas, such as visual-motor psychophysics and rehabilitation. Currently, academic research on motor acuity is scarce. The embodiments of this invention can fill this critical gap in research on human motor behavior and visual-motor psychophysics. Similar to all examples of motor skill learning characterized by reinforcement learning, the goal of physical rehabilitation is to improve motor acuity. Rehabilitation must also assess performance to provide motivating feedback to patients and clinically relevant data for therapists or clinicians to guide rehabilitation. Neuroplasticity drives motor learning, which depends on the repetition of movements and the intensity of training. Active participation and enjoyment of tasks also promote neuroplasticity. Furthermore, adjusting task difficulty according to individual skill levels is crucial for rehabilitation, as competence is an intrinsic driving force. Embodiments, such as the FSA approach, can meet all these criteria and improve such techniques by providing challenging, adaptive, and engaging tasks based on repetitive motor behaviors. Integrating FSA methods into gamified rehabilitation techniques can objectively quantify behavioral or motor performance (e.g., kinematics, dynamics), and can be rapidly and cost-effectively deployed on a large scale to remotely serve a wide population.

[0160] Some implementations include gamified assessments of sensorimotor and / or cognitive fitness or status. These implementations may include immersive games for military personnel, performed on mobile devices (e.g., telephones, desktop computers, etc.), and assess and monitor changes in cognitive fitness, readiness, and performance throughout the military cycle and in combat environments. In some implementations, baseline performance is measured through an initial training session, and changes in an individual's cognitive performance relative to their baseline are monitored through repeated play. In some implementations, the assessment is sensitive to subtle changes in cognitive fitness (e.g., due to fatigue, injury, mental illness, drug or alcohol use, or any of many other factors). Implementations may provide dashboards for tracking personnel's sensorimotor and cognitive fitness to support decisions, such as whether intervention is needed, whether personnel should be temporarily withdrawn, or returned to active duty.

[0161] The disclosed gamified assessment method for sensorimotor and cognitive fitness offers numerous advantages over other methods, including standard neuropsychological assessment suites. The implementation scheme for gamified assessment of sensorimotor and cognitive fitness improves assessment techniques due to its entertainment value, immersiveness, objectivity, and ease of distribution because it does not rely on specialized hardware or peripherals. The implementation scheme can be implemented without the presence of a medical professional. The implementation scheme can be personalized (e.g., relative to each individual's baseline), thus remaining sensitive to subtle changes in cognitive fitness that may be undetectable by standard neuropsychological assessment suites. The implementation scheme can be completed in less time than standard neuropsychological assessment suites.

[0162] Some implementations, such as those described herein, use computer systems to detect sandbagging (intentionally underperforming in baseline assessments) by analyzing performance variability. Human performance exhibits a typical error distribution. While players may attempt sandbagging (e.g., perform below their actual ability level), they struggle to mimic this typical error distribution when sandbagging. Furthermore, less skilled players generally respond slower and have greater bias (or lower precision or accuracy) but still adhere to the task's speed-accuracy tradeoff incentives, whereas intentionally sandbagging players exhibit poorer speed and precision (or higher variability or lower accuracy) regardless of the task incentives. When sandbagging is detected, the implementation can notify coaches, commanders, managers, etc.

[0163] In one validation of several implementations, performance data from 32 professional and semi-professional male esports players (mean age = 22.47 ± 3.62) were collected and subsequently analyzed. Players specialized in different games: 4 specialized in Valorant, 10 in PUBG, and 18 in Rainbow Six Siege. Each participant completed several rounds of Gridshot and several rounds of Sixshot missions. Systematic differences in player movement were expected between Gridshot and Sixshot missions. The large target size of Gridshot incentivized players to move as quickly as possible with relatively low shooting accuracy to maximize their score. The much smaller Sixshot target required high accuracy, thus incentivizing players to slow down.

[0164] In a demonstration and validation by the FSA, data from a large number of amateur players, each of whom completed multiple rounds of the Adaptive Reflexshot task with three different target sizes, was analyzed. Each game round used a single target size, and the target presentation duration was dynamically adjusted within each round based on player performance. Different target sizes were presented during individual game rounds. Figure 11 (Top left subplot) shows the rate of fire as a function of shooting variability (in degrees) or firing rate (in shots per second) for two example players according to one implementation scheme. Figure 11 (Top right subplot) shows the shooting accuracy as a function of shooting accuracy (in example units of 1 / (divided by) shooting variability in degrees-1) or shooting rate as a function of shooting accuracy (in example units of shots / second) for the same two example players.

[0165] Some implementation schemes compare flick shot skills among multiple players. Figure 11 (Bottom subplot) shows an example distribution of the flick shot skill values ​​for a group of amateur players. The flick shot skill values ​​of two example players ( Figure 11 The top two sub-graphs) and the overall player distribution ( Figure 11 Compare the bottom sub-images.

[0166] The implementation plan can assess flick shot skills and movement frequency. Human flick shot performance typically exhibits variability and error. Sometimes, the initial movement error is minimal, while in other cases, subsequent corrective movements are required to successfully land and fire at the target. For large targets, the proportion of targets expected to require corrective movements to be destroyed will be less. This is because even with movement error, the initial movement is more likely to land on the target. On the other hand, for small targets, players often have to make corrective movements to adapt to the much smaller target. In an example validation, data from professional (and semi-professional) esports players was used for validation. In this example validation, the percentage of targets destroyed by a single movement (initial movement) or by a pair of movements (initial movement and corrective movement) was counted for both tasks. Statistical analysis (e.g., using error bars) yielded the standard deviation among players. The results reflected the predicted pattern: across all players, the number of single movements used to destroy targets in the Gridshot task was greater than in the Sixshot task. Similarly, across all players, the frequency of single movements used to destroy targets in the Sixshot task was lower than that of double movements. Furthermore, aside from the two players, the situation is quite the opposite in Gridshot missions; most targets are destroyed with a single movement.

[0167] In an example validation against FSA, flick shot skill can predict the number of moves required to destroy a target. For the Gridshot task and for the Sixshot task, flick shot skill can be plotted on the x-axis (e.g., after regression to eliminate the influence of mouse sensitivity), and the percentage of targets destroyed after a single move can be plotted on the y-axis. This validation can use statistical results from Spearman rank correlation: rho = Spearman correlation coefficient and p = p-value; for example, p-value < 0.05. In one validation, flick shot skill may be positively correlated with the proportion of targets destroyed with a single move in Gridshot [p = 4.19e-04]. This suggests that players with better flick shot skill are more likely to destroy targets with only a single move, and therefore their actions are more efficient in Gridshot.

[0168] Movement kinematic metrics can be task-related. Figure 12 Example verification of embodiments of the present invention for measuring mobility kinematics is provided, and it is confirmed that FSA reflects mobility kinematic indices. Figure 12 Example kinematics of movement are plotted for the Gridshot and Sixshot tasks, with the x-axis indicating Gridshot and the y-axis indicating Sixshot. Each subplot corresponds to a different kinematics of movement for the initial move. Each data point within each subplot corresponds to a different player. The dashed diagonal lines in each subplot represent the values ​​when the kinematics of movement in Gridshot and Sixshot are exactly the same. Figure 12 The annotation box shows the statistical results from the paired Wilcoxon signed-rank test: where w = rank sum and p = p-value. A p-value < 0.05 indicates a statistically significant difference in movement kinematics for Gridshot and Sixshot. The results confirm that, in this example, players exhibit greater undershoot in Sixshot compared to Gridshot (accuracy). Compared to Sixshot, players react faster in Gridshot (reaction time), move the mouse at a faster pace (speed), and fire earlier in their movement trajectory (slide shot tendency).

[0169] Figure 13 The embodiments of the present invention are provided as examples of FSA validation, demonstrating that differences in individual gun-flicking skill values ​​(such as those measured by FSA) can predict differences in individual movement kinematics. Figure 13Each subplot in the graph plots one of the movement kinematics metrics on the y-axis (normalized by z-score and regression-rejected to remove the influence of mouse sensitivity), while the x-axis corresponds to motion acuity (measured via FSA, also normalized by z-score and regression-rejected to remove the influence of mouse sensitivity). Each data point within each subplot corresponds to a different player. The left column of the graph plots the movement kinematics metrics for the Gridshot task, and the right column plots the movement kinematics metrics for the Sixshot task. Figure 13 The annotation boxes in the table show the statistical results from Spearman rank correlation: rho = Spearman correlation coefficient and p = p-value. A p-value < 0.05 indicates that FSA can predict individual differences in movement kinematics. For Gridshot, movement acuity was negatively correlated with reaction time and gliding tendency, but positively correlated with accuracy, speed, and precision. For Sixshot, movement acuity was negatively correlated with reaction time and gliding tendency, but positively correlated with precision. The interpretation of these results for both tasks is that players with higher movement acuity initiate movement faster, land with lower variability, and fire earlier in the movement trajectory. Furthermore, players with higher movement acuity exhibited faster movement speed and better (lower amplitude) accuracy in Gridshot. Therefore, individual differences in FSA can be used as a proxy indicator for measuring movement kinematic characteristics.

[0170] Figures 11 to 13 Together, these studies demonstrate the ability of each implementation scheme to assess individual players' flick-shooting skills. These validation results reveal differences between professional FPS players, amateur players, and in scenarios with varying mission requirements:

[0171] -- Players adjust their strategies across different missions, each with a different emphasis on speed and accuracy. This is evident in the player's shooting behavior: when the target is large (Gridshot), more shots are fired with greater spatial error, while when the target is very small (Sixshot), fewer shots are fired with less spatial error.

[0172] --Movement kinematics reflect mission requirements. Compared to Sixshot, in Gridshot, players initiate their movement to the target faster (e.g., with shorter reaction times) and have higher movement speeds (both for initial and corrective movements). Compared to Sixshot, players fire earlier in their movement trajectory in Gridshot (e.g., with lower slide-fire propensity values). In other words, players adopt a more conservative strategy in Sixshot compared to Gridshot. Kinematic metrics provide details about the nature of this inter-mission strategy shift, which would otherwise appear obscure, as players could potentially increase their firing speed through a combination of various basic kinematic variations. Specifically, compared to Gridshot, players need more time to plan their movement, move slower, fire later in their trajectory, and are more likely to undershoot in Sixshot. Therefore, players sacrifice speed for accuracy and exhibit a more conservative (undershoot) landing position.

[0173] Players differ in their ability to balance speed and accuracy, which is reflected in the position of their speed-accuracy trade-off curve. Players with higher flick shot skills (e.g., their speed-accuracy trade-off curve is more skewed to the upper right or further from the origin) are faster and more accurate than players with lower flick shot skills, and may also have higher performance levels or greater agility.

[0174] --Flick shot skill is correlated with certain kinematic metrics. In the Gridshot and Sixshot tests, stronger flick shot skill is not only accompanied by faster reaction time, but also higher accuracy in Gridshot and a greater tendency to fire earlier in the trajectory (i.e., a tendency to slide fire). It is important to note that in this example validation, the flick shot skill value and the kinematic metrics values ​​are derived from different performance metrics, namely the shooting performance metric and the kinematic metrics. Confirming the systematic relationship between the two is a key validation of FSA.

[0175] --Flick shot skill is related to movement efficiency. Compared to Sixshot, in Gridshot players can more frequently destroy targets successfully with a single movement, while in Sixshot most targets are destroyed only after a movement correction.

[0176] --Individual differences in flick shot skill are correlated with the proportion of targets destroyed in a single movement in Gridshot. In other words, those with higher flick shot skill values ​​in Gridshot tend to destroy a given target with just one movement. This underscores the predictive power of FSA, as those with higher rate of fire and higher accuracy have also proven to be more efficient, requiring fewer movements while demonstrating better flick shot skill.

[0177] --To verify some aspects of embodiments of the invention, professional esports athletes (specializing in several different games) were recruited to perform two tasks (e.g., each task with different target sizes), one task emphasizing speed incentives and the other emphasizing accuracy incentives. For further verification, data from a large number of amateur players were analyzed. Each player's flick-shooting skills were evaluated by measuring the speed-accuracy trade-offs for various target types or sizes, for example, the correlation between firing speed (e.g., median firing time from target appearance to first shot, even if the first shot misses in some embodiments) and firing accuracy (e.g., 1 divided by the median absolute value of the firing error). An improvement over existing evaluation techniques is that individual differences in this invention can highly predict individual differences in movement efficiency (e.g., the number of movements required to hit a target) and individual differences in movement kinematics (e.g., reaction time, accuracy, and tendency to glide).

[0178] Unless explicitly stated otherwise, the implementation schemes of the methods described herein are not limited to a specific order or sequence. Furthermore, all formulas described herein are for illustrative purposes only, and other or different formulas may be used. Additionally, some of the described method implementation schemes or elements thereof may occur or be performed at the same point in time.

[0179] While certain features of the invention have been illustrated and described herein, many modifications, substitutions, alterations, and equivalents will be apparent to those skilled in the art. Therefore, it should be understood that the appended claims are intended to cover all such modifications and alterations falling within the essential spirit of the invention.

[0180] Multiple implementation schemes have been presented. Of course, each of these implementation schemes may include features of other presented implementation schemes, and implementation schemes not specifically described may include the various features described herein.

Claims

1. A computer-implemented method for adjusting the evaluation of an input signal, said input signal being derived from a computer input device used by a player of a game, the method comprising: The input made by the player using a computer input device in the game is monitored by at least one computer processor; Determine the performance metrics of the input; as well as The at least one processor adjusts the relationship between input received via the computer input device and the movement of virtual objects within the virtual environment of the game based on the performance metrics, wherein the adjustment includes setting multiple sensitivities on the computer input device, each sensitivity being for a different movement direction of the virtual object.

2. The method as described in claim 1, wherein, The relationship affects the number of dots per inch that the virtual object moves when the computer input device moves one unit.

3. The method as described in claim 1, wherein, The adjustment uses a parameterized definition of sensitivity, with each parameter describing a direction of movement.

4. The method of claim 1, wherein, The performance metrics include at least one of the following: the distance between the projectile and the target; and the distance between the projectile and the target.

5. The method of claim 1, wherein, The computer input device includes a device selected from the following: mouse; game controller; joystick; accelerometer; pointing device; motion capture device; Wii remote control; eye tracker; computer vision system; gyroscope; Absolute position head-mounted device; six-degree-of-freedom head-mounted device; and inside-out tracking head-mounted device.

6. The method of claim 1, wherein, The input includes aiming or target positioning movement trajectory.

7. The method of claim 1, wherein, Adjusting the relationship includes manipulating at least one of acceleration and velocity.

8. The method of claim 1, wherein, The adjustment includes manipulating at least one of the following: the input position, velocity, acceleration, higher-order time derivative of the position, orientation, angular velocity, angular acceleration, higher-order time derivative of the orientation, joint angle, angular velocity of the joint angle, angular acceleration of the joint angle, higher-order time derivative of the joint angle, DPI, lift distance, polling rate, button response / debounce time, and angle adjustment.

9. The method of claim 1, wherein, The virtual object is a virtual character.

10. The method of claim 1, wherein, The adjustment of the relationship is performed by a computer program that includes the game.

11. The method of claim 1, wherein, The adjustment of the relationship is performed by the input device.

12. The method of claim 1, wherein, The performance indicators are selected from: kinematic performance indicators, shooting performance indicators, speed, accuracy, precision, variability, positional error, reaction time, agility, and score.

13. The method of claim 1, wherein, Determining the performance metrics of the movement includes determining the performance metrics of the movement's trajectory.

14. The method of claim 1, wherein, The performance metrics are based on one or more of the following: mean; median; mode; variance; covariance; skewness; kurtosis; movement speed; peak movement speed; rate of fire; and a metric based on a target presentation duration threshold. A metric based on target hit rate; A metric based on the time between target generation or appearance and the first shot being fired; A metric based on the number of movements per second; A metric based on the number of shots per second; Mobility variability; Shot variability; a measure of spatial error from the moving point of impact to the target; A measure based on the median absolute difference between the endpoint of the movement and the center of the target; And a metric based on a target size threshold.

15. A system for adjusting the evaluation of an input signal, said input signal being derived from a computer input device used by a player of a game, said system comprising: Memory; as well as One or more processors, said one or more processors being configured to: Monitor player input using computer input devices in the game; Determine the performance metrics of the input; and The relationship between the input received via the computer input device and the movement of virtual objects within the game's virtual environment is adjusted based on the performance metrics of the input. The performance metric is determined by a processor selected from: a processor located remote from the one or more processors; and the one or more processors. The adjustment includes setting multiple sensitivities on the computer input device, each sensitivity being for a different movement direction of the virtual object.

16. The system of claim 15, wherein, The performance metrics include at least one of the following: the distance between the projectile and the target; and the distance between the projectile and the target.

17. The system of claim 15, wherein, The computer input device includes a device selected from the following: mouse; game controller; joystick; accelerometer; pointing device; motion capture device; Wii remote control; eye tracker; computer vision system; gyroscope; Absolute position head-mounted device; six-degree-of-freedom head-mounted device; and inside-out tracking head-mounted device.

18. The system of claim 15, wherein, The relationship affects the number of dots per inch that the virtual object moves when the computer input device moves one unit.

19. The system of claim 14, wherein, The adjustment uses a parameterized definition of sensitivity, with each parameter describing a direction of movement.

20. The system of claim 15, wherein, The input includes aiming or target positioning movement trajectory.

21. The system of claim 15, wherein, Adjusting the relationship includes manipulating at least one of acceleration and velocity.

22. The system of claim 15, wherein, The performance metrics are based on one or more of the following: mean; median; mode; variance; covariance; skewness; kurtosis; movement speed; peak movement speed; rate of fire; and a metric based on a target presentation duration threshold. A metric based on target hit rate; A metric based on the time between target generation or appearance and the first shot being fired; A metric based on the number of movements per second; A metric based on the number of shots per second; Mobility variability; Shot variability; a measure of spatial error from the moving point of impact to the target; A measure based on the median absolute difference between the endpoint of the movement and the center of the target; And a metric based on a target size threshold.

23. The system of claim 15, wherein, The adjustment includes manipulating at least one of the following: the input position, velocity, acceleration, higher-order time derivative of the position, orientation, angular velocity, angular acceleration, higher-order time derivative of the orientation, joint angle, angular velocity of the joint angle, angular acceleration of the joint angle, higher-order time derivative of the joint angle, DPI, lift distance, polling rate, button response / debounce time, and angle adjustment.

24. The system of claim 15, wherein, The virtual object is a virtual character.

25. The system of claim 15, wherein, The adjustment of the relationship is performed by a computer program that includes the game.

26. The system of claim 15, wherein, The adjustment of the relationship is performed by the input device.

27. A method for adjusting the evaluation of an input signal, the input signal being from a computer input device used in a virtual environment, the method comprising: The computer processor monitors the input to the virtual environment using a computer input device; Determine the performance metrics of the input; The processor adjusts the mapping between input received via the computer input device and movement within the virtual environment based on the performance metrics, wherein the adjustment includes setting multiple sensitivities on the computer input device, each sensitivity for a different direction of movement.

28. The method of claim 27, wherein, The performance metrics include at least one of the following: the distance between the projectile and the target; and the distance between the projectile and the target.

29. The method of claim 27, wherein, The computer input device includes a mouse.

Images