Electronic device and method for inputs on screen on which game play is streamed, and non-transitory computer-readable storage medium

Abstract

This electronic device may comprise: a memory for storing instructions; a communication circuit; and at least one processor. When executed by the at least one processor, the instructions can instruct the electronic device to: display, on a display, a screen including a plurality of executable objects including first executable objects for controlling a game and second executable objects for controlling a player character in the game; stream the screen on an external electronic device by using the communication circuit; receive a first input distinguished from an input designated to execute each of the plurality of executable objects; provide a first mode for deactivating preset executable objects and other executable objects; receive a second input while the first mode is provided; execute a function selected according to the second input from among functions corresponding to each of preset objects; and change a mode for the game to a second mode for activating the plurality of executable objects.

Description

Electronic device, method, and non-transitory computer-readable storage medium for input to a screen streamed for game play

[0001] The descriptions below relate to an electronic device, a method, and a non-transitory computer readable storage medium for input to a screen that is streamed for game play.

[0002] An electronic device may include a communication circuit and a display. The display may be used to display a screen. The communication circuit may be used to stream the screen to an external electronic device. Streaming may refer to a technique of transmitting and / or receiving data about the screen to the external electronic device via the communication circuit. For example, the data may cause the external electronic device to display the screen (or a screen corresponding to the screen) on a display associated with the external electronic device. For example, the data may cause the external electronic device to output audio related to the screen through a speaker associated with the external electronic device. For example, the data may be generated or acquired within the electronic device using a software application for a game installed (or stored) within the electronic device.

[0003] The above information may be provided as background art to aid in understanding the present disclosure.

[0004] No claim or determination is made as to whether any of the above is applicable as prior art to the present disclosure.

[0005] An electronic device is provided. The electronic device may include a memory for storing instructions and including one or more storage media. The electronic device may include communication circuitry. The electronic device may include a display. The electronic device may include at least one processor including processing circuitry. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to display, on the display, a screen comprising a plurality of executable objects provided from a software application for a game, the screen comprising first executable objects for controlling the game and second executable objects for controlling a player character within the game. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to stream, using the communication circuitry, the screen to an external electronic device for displaying the screen on a display of the external electronic device. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to receive a first input distinct from an input designated to execute each of the plurality of executable objects while the screen is streamed to the external electronic device.The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to, in response to the first input, provide a first mode that deactivates the preset executable objects from among the plurality of executable objects and other executable objects until a function corresponding to each of the preset executable objects from among the plurality of executable objects is selected in response to a second input. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to receive the second input while the first mode is provided. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to, in response to the second input, execute the function selected in response to the second input from among the functions corresponding to each of the preset executable objects from among the plurality of executable objects, and to change the mode for the game from the first mode to a second mode that activates the plurality of executable objects.

[0006] A method is provided. The method can be executed in an electronic device having a communication circuit and a display. The method can include an operation of displaying, on the display, a screen, the screen including a plurality of executable objects provided from a software application for a game, the executable objects including first executable objects for controlling the game and second executable objects for controlling a player character within the game. The method can include an operation of streaming the screen to an external electronic device using the communication circuit for displaying the screen on the display of the external electronic device. The method can include an operation of receiving, while the screen is being streamed to the external electronic device, a first input distinct from an input designated for executing each of the plurality of executable objects. The method can include an operation of providing, in response to the first input, a first mode for deactivating executable objects other than the preset executable objects from among the plurality of executable objects until one function corresponding to each of the preset executable objects from among the plurality of executable objects is selected in response to a second input. The method may include an operation of receiving the second input while the first mode is provided. The method may include an operation of executing, in response to the second input, the function selected from among the functions corresponding to the preset executable objects among the plurality of executable objects according to the second input, and changing the mode for the game from the first mode to a second mode that activates the plurality of executable objects.

[0007] A non-transitory computer-readable storage medium is provided. The non-transitory computer-readable storage medium may store one or more programs. The one or more programs may include instructions that, when executed by an electronic device having a display and communication circuitry, cause the electronic device to display, on the display, a screen comprising a plurality of executable objects provided from a software application for a game, the screen comprising first executable objects for controlling the game and second executable objects for controlling a player character within the game. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to stream, using the communication circuitry, the screen to an external electronic device for displaying the screen on the display of the external electronic device. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to receive a first input distinct from an input designated for executing each of the plurality of executable objects while the screen is being streamed to the external electronic device. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to, in response to the first input, provide a first mode that deactivates the preset executable objects and other executable objects from among the plurality of executable objects until one function corresponding to each of the preset executable objects from among the plurality of executable objects is selected in response to a second input. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to receive the second input while the first mode is provided.The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to, in response to the second input, execute a function selected from among the functions corresponding to the preset executable objects among the plurality of executable objects, respectively, and change the mode for the game from the first mode to a second mode that activates the plurality of executable objects.

[0008] Figure 1 illustrates an example of streaming a screen from a software application for a game to an external electronic device.

[0009] FIG. 2 illustrates an example of multiple executable objects displayed within a screen that is streamed to an external electronic device.

[0010] Figure 3 is a simplified block diagram of an exemplary electronic device.

[0011] FIG. 4 is a flowchart illustrating an exemplary method for providing a first mode and a second mode for a game.

[0012] FIG. 5 illustrates an example of a first input received by an electronic device to provide a first mode for a game.

[0013] Figures 6a and 6b illustrate examples of a first mode for a game.

[0014] Figures 7a and 7b illustrate examples of visual affordances displayed according to the first mode for the game.

[0015] Figures 8a, 8b, 8c, and 8d illustrate examples of third inputs received for visual affordances displayed according to a first mode for a game.

[0016] Figure 9 illustrates an example of a first input received to change the mode for a game from a first mode to a second mode.

[0017] FIG. 10 illustrates an example of changing the mode for a game from the first mode to the second mode based on a second input that is not received during a reference time while at least one processor provides the first mode for the game.

[0018] FIG. 11 illustrates an example of interconnected servers and one or more user terminals for a game service.

[0019] Figures 12a, 12b and 12c illustrate exemplary cases of providing a game-related user experience using multiple user terminals.

[0020] Electronic devices (or external electronic devices) according to various embodiments disclosed in this document may take various forms. Electronic devices may include, for example, portable communication devices (e.g., smartphones), computer devices, portable multimedia devices, portable medical devices, cameras, wearable devices, servers, or home appliances. Electronic devices (or external electronic devices) according to embodiments of this document are not limited to the aforementioned devices.

[0021] The various embodiments of this document and the terminology used herein are not intended to limit the technical features described in this document to specific embodiments, but should be understood to include various modifications, equivalents, or substitutes of the embodiments. In connection with the description of the drawings, similar reference numerals may be used for similar or related components. The singular form of a noun corresponding to an item may include one or more items, unless the context clearly indicates otherwise. In this document, phrases such as "A or B," "at least one of A and B," "at least one of A or B," "A, B, or C," "at least one of A, B, and C," and "at least one of A, B, or C" can each include any one of the items listed together in that phrase, or all possible combinations thereof. Terms such as "first," "second," or "first" or "second" may be used merely to distinguish the corresponding component from other corresponding components, and do not limit the corresponding components in any other respect (e.g., importance or order). When a component (e.g., a first component) is referred to as being “coupled” or “connected” to another component (e.g., a second component), with or without the terms “functionally” or “communicatively,” it means that the component can be connected to the other component directly (e.g., wired), wirelessly, or through a third component.

[0022] The term "module" as used herein may include a unit implemented in hardware, software, or firmware, and may be used interchangeably with terms such as logic, logic block, component, or circuit. A module may be an integral component, or a minimum unit or part of a component that performs one or more functions. For example, according to one embodiment, a module may be implemented in the form of an application-specific integrated circuit (ASIC).

[0023] Various embodiments of the present document may be implemented as software (e.g., a program) including one or more instructions stored in a storage medium that can be read by a machine (e.g., an electronic device (100)). For example, a processor of the machine (e.g., an electronic device (100)) may call at least one instruction among the one or more instructions stored from the storage medium and execute it. This enables the machine to operate to perform at least one function according to the at least one instruction called. The one or more instructions may include code generated by a compiler or code that can be executed by an interpreter. The machine-readable storage medium may be provided in the form of a non-transitory storage medium. Here, 'non-transitory' only means that the storage medium is a tangible device and does not contain a signal (e.g., an electromagnetic wave), and this term does not distinguish between cases where data is stored semi-permanently and cases where it is stored temporarily in the storage medium.

[0024] According to one embodiment, the method according to various embodiments disclosed in the present document may be provided as included in a computer program product. The computer program product may be traded as a product between a seller and a buyer. The computer program product may be distributed in the form of a machine-readable storage medium (e.g., compact disc read only memory (CD-ROM)), or may be distributed online (e.g., downloaded or uploaded) via an application store (e.g., Play Store™ or App Store™) or directly between two user devices (e.g., smartphones). In the case of online distribution, at least a portion of the computer program product may be temporarily stored or temporarily generated in a machine-readable storage medium, such as the memory of a manufacturer's server, an application store's server, or an intermediary server.

[0025] According to various embodiments, each component (e.g., a module or a program) of the described components may include one or more entities. According to various embodiments, one or more components or operations of the aforementioned components may be omitted, or one or more other components or operations may be added. Alternatively or additionally, a plurality of components (e.g., a module or a program) may be integrated into a single component. In such a case, the integrated component may perform one or more functions of each of the plurality of components identically or similarly to those performed by the corresponding component among the plurality of components prior to integration. According to various embodiments, the operations performed by a module, program, or other component may be executed sequentially, in parallel, iteratively, or heuristically, or one or more of the operations may be executed in a different order, omitted, or one or more other operations may be added.

[0026] Figure 1 illustrates an example of streaming a screen from a software application for a game to an external electronic device.

[0027] Referring to FIG. 1, the electronic device (100) may be usable to stream a screen (120) related to a game to an external electronic device (e.g., an external electronic device (130)). For example, the electronic device (100) may display a screen (120) provided from a software application for a game installed (or stored) in the electronic device (100) through the display (110). For example, the electronic device (100) may stream the screen (120) to the external electronic device (130) by transmitting data (160) regarding the screen (120) displayed through the display (110) to the external electronic device (130).

[0028] For example, the electronic device (100) may receive input for a game (or for playing a game). As a non-limiting example, the input may include a touch input on the display (110), a tap input on the rear exterior of the electronic device (100), or an input that causes the electronic device (100) to make a predetermined movement.

[0029] An external electronic device (130) may be available to display a screen (150) streamed from an electronic device (100). For example, the external electronic device (130) may use a communication circuit to stream the screen (120) of the electronic device and display it on a display (140) associated with the external electronic device (130).

[0030] For example, an external electronic device (130) can display a screen (150) corresponding to a screen (120) on a display (140) associated with the external electronic device (130) using data (160) received from the electronic device (100).

[0031] For example, the display (140) may be included within the external electronic device (130). For example, the display (140) may include a display located outside the external electronic device (130) and connected to the external electronic device (130). However, the present invention is not limited thereto.

[0032] For example, the arrangement of objects (e.g., executable objects as exemplified below) within the screen (150) may be identical to, or at least partially different from, the arrangement of objects within the screen (120). For example, the size of the screen (150) may be larger than the size of the screen (120). As a non-limiting example, because the size of the screen (150) is larger than the size of the screen (120), the visibility of the screen (150) may be higher than the visibility of the screen (120).

[0033] FIG. 2 illustrates an example of multiple executable objects displayed within a screen that is streamed to an external electronic device.

[0034] Referring to FIG. 2, the screen (120) of the electronic device (100) may include a plurality of executable objects.

[0035] For example, the screen (120) may include first executable objects (200). For example, the first executable objects (200) may include executable objects for controlling a game.

[0036] For example, the first executable objects (200) may include at least one executable object (200-1) for providing a map of an environment within the game that includes a player character. For example, the first executable objects (200) may include at least one executable object (200-2) for purchasing and selling virtual items for the player character. For example, the first executable objects (200) may include at least one executable object (200-3) for displaying a list of missions provided by a non-player character for the player character's progress in the game.

[0037] For example, the first executable objects (200) may include at least one executable object (200-4) for displaying a list of virtual items owned by the player character. For example, the first executable objects (200) may include at least one executable object (200-5) for displaying a list of functions for setting the game's volume, setting the video quality, and / or updating the game. For example, the first executable objects (200) may include at least one executable object (200-6) for providing a list of other game users.

[0038] For example, the first executable objects (200) may include at least one executable object (200-7) for providing a service that allows a game user to send and / or receive messages with other game users. For example, the first executable objects (200) may include an executable object (200-8) for providing a first action of a player character set by a user of the game (e.g., an executable object that provides a shortcut to the first action). For example, the first executable objects (200) may include an executable object (200-9) for providing a second action of a player character set by a user of the game (e.g., an executable object that provides a shortcut to the second action). For example, the first executable objects (200) may include at least one executable object (200-10) for using a virtual item set by a user of the game among virtual items. However, the present invention is not limited thereto.

[0039] For example, the screen (120) may include second executable objects (210). For example, the second executable objects (210) may include objects for controlling a player character within the game. As a non-limiting example, the second executable objects (210) may include an executable object (210-1) for changing the direction and / or movement of the player character. For example, the second executable objects (210) may include an executable object (210-2) for providing predefined actions of the player character. For example, the second executable objects (210) may include an executable object (210-3) for providing actions of the player character that apply to other player characters and / or non-player characters. For example, the second executable objects (210) may include an executable object (210-4) for the player character to acquire a virtual item within the game.

[0040] As a non-limiting example, use of the second executable objects (210) during game play may be more frequent than use of the first executable objects (200) during game play. For example, inputs to at least some of the second executable objects (210) may be received more frequently than inputs to at least some of the first executable objects (200).

[0041] For example, since input for at least some of the second executable objects (210) is received more frequently than input for at least some of the first executable objects (200), the user may cause input for at least some of the second executable objects (210) while looking at the screen (150) among the screens (120) and (150), as opposed to causing input for at least some of the first executable objects (200). For example, the first executable objects (200) may be described as a preferred executable object for a user who focuses on the screen (120) among the screens (120) and (150), and the second executable objects (210) may be described as a preferred executable object for a user who focuses on the screen (150) among the screens (120) and (150).

[0042] For example, while it is possible for a user to cause input to second executable objects (210) within state (291) and state (292), a user playing the game may prefer causing input to second executable objects (210) within state (291) to causing input to second executable objects (210) within state (292).

[0043] For example, it may be possible for a user to cause input to the first executable objects (200) within a state (292), but it may be practically impossible for a user to cause input to the first executable objects (200) within a state (291). For example, causing input to the first executable objects (200) within a state (292) among states (291) and (292) may cause inconvenience to a user playing the game. For example, causing input to the first executable objects (200) within a state (292) may not be preferred by the user because an unexpected (or unpredicted) situation may occur while the state (291) is being changed to the state (292) within the game being played by the user.

[0044] For example, since triggering input to the first executable objects (200) within a state (292) may not be preferred by the user, a method for triggering input to the first executable objects (200) within a state (291) may be executed within the electronic device (100). For example, the electronic device (100) may provide a first mode for a game (illustrated below) to trigger input to the first executable objects (200) within the state (291). For example, the electronic device (100) may provide for changing the mode for a game from a second mode (illustrated below) to the first mode. For example, the electronic device (100) may provide for changing the mode for a game from the first mode to the second mode.

[0045] The electronic device (100) may include components (or hardware components) for providing such a method. The components are described and illustrated in more detail with reference to FIG. 3.

[0046] Figure 3 is a simplified block diagram of an exemplary electronic device.

[0047] Referring to FIG. 3, the electronic device (100) may include a display (110), at least one processor (300), a communication circuit (310), and a memory (320).

[0048] The display (110) may include hardware components of the electronic device (100) used to display a screen (e.g., screen (120)). For example, the display (110) may include light-emitting elements and circuits (e.g., transistors) that control the light-emitting elements to emit light. For example, each of the light-emitting elements may include an organic light emitting diode (OLED) or a micro LED. However, the present invention is not limited thereto. For example, the display (110) may include a liquid crystal display (LCD).

[0049] At least one processor (300) may include a hardware component for processing data based on executing instructions. The hardware component for processing data may include, for example, a central processing unit (CPU) (e.g., including processing circuitry). For example, the hardware component for processing data may include a graphics processing unit (GPU) (e.g., including processing circuitry). For example, the hardware component for processing data may include a display processing unit (DPU) (e.g., including processing circuitry).

[0050] At least one processor (300) may include one or more cores. For example, at least one processor (300) may have a multi-core processor structure such as a dual core, quad core, or hexa core.

[0051] The memory (320) may include a hardware component for storing data and / or instructions input to and / or output from at least one processor (300). The memory (320) may include, for example, volatile memory such as random-access memory (RAM) and / or non-volatile memory such as read-only memory (ROM). The volatile memory may include, for example, at least one of dynamic RAM (DRAM), static RAM (SRAM), cache RAM, and pseudo SRAM (PSRAM). The non-volatile memory may include, for example, at least one of programmable ROM (PROM), erasable PROM (EPROM), electrically erasable PROM (EEPROM), flash memory, hard disk, compact disc, and embedded multimedia card (EMMC).

[0052] The communication circuit (310) may include hardware components for supporting transmission and / or reception of signals between the electronic device (100) and the external electronic device (130). The communication circuit (310) may include, for example, at least one of a modem, an antenna, and an optical / electronic (O / E) converter. The communication circuit (310) may support transmission and / or reception of electrical signals based on various types of protocols, such as Ethernet, a local area network (LAN), a wide area network (WAN), wireless fidelity (WiFi), Bluetooth, Bluetooth low energy (BLE), zigbee, long term evolution (LTE), and 5G new radio (NR).

[0053] For example, at least one processor (300) may execute instructions stored in the memory (320) to provide the first mode for a game, to provide the second mode for a game, to change the mode for a game from the first mode to the second mode, and / or to change the mode for a game from the second mode to the first mode. For example, the instructions, when individually or collectively executed by the at least one processor (300), may cause the electronic device (100) to provide the first mode for a game, to provide the second mode for a game, to change the mode for a game from the first mode to the second mode, and / or to change the mode for a game from the second mode to the first mode. These operations are described and illustrated in more detail with reference to FIGS. 4 to 10 .

[0054] FIG. 4 is a flowchart illustrating an exemplary method for providing a first mode and a second mode for a game.

[0055] Referring to FIG. 4, in operation 410, at least one processor (300) may display a screen (120) provided from a software application for a game through a display (110), as illustrated in FIGS. 1 and 2. For example, the screen (120) may include a plurality of executable objects, as illustrated in FIGS. 1 and 2. For example, the plurality of executable objects may include first executable objects (200), as illustrated in the description of FIG. 2. For example, the plurality of executable objects may include second executable objects (210), as illustrated in the description of FIG. 2.

[0056] In operation 420, at least one processor (300) may stream the screen (120) to an external electronic device (130) using the communication circuit (310). For example, the external electronic device (130) may receive data (e.g., data (160)) regarding the screen (120) from the electronic device (100) according to the streaming. For example, the external electronic device (130) may display the screen (150) on a display (e.g., display (140)) associated with the external electronic device (130) using the data (160). For example, the screen (150) may correspond to the screen (120).

[0057] In operation 430, the electronic device (100) may receive a first input while the screen (120) is being streamed to the external electronic device (130). For example, the first input may represent an input that causes the electronic device (100) to provide the first mode for a game, as exemplified below. For example, the first input may represent an input that causes the electronic device (100) to enter the first mode. For example, the first input may represent an input received to activate the first mode while the user is looking at the screen (150), as in state (291). For example, the first input may not be intended to cause the user to look at the screen (120), as in state (292). The first input is described and exemplified in more detail with reference to FIG. 5 .

[0058] FIG. 5 illustrates an example of a first input received by an electronic device to provide a first mode for a game.

[0059] Referring to FIG. 5, the first input may be distinguished from a touch input on each of a plurality of executable objects (e.g., including first executable objects (200) and second executable objects (210). For example, the first input may be distinguished from an input designated to execute each of the plurality of executable objects. For example, the first input may be distinguished from an input received for a specific location (or a predetermined location) (or a predefined location) within the screen (120) to which a function is mapped. For example, the first input may be distinguished from a touch input on each of the plurality of executable objects that is recognized by identifying the locations of contact points (or a point of contact) on the screen (120) and executing a function corresponding to the identified location. As a non-limiting example, the first input may be more intuitive compared to the touch input.

[0060] For example, the first input may include identifying a predetermined movement of the electronic device (100) via a sensor configured to obtain data about movement of the electronic device (100), such as state (510). For example, at least one processor (300) may obtain data representing the movement of the electronic device (100) via the sensor, identify (or determine) whether the movement of the electronic device (100) represented by the data corresponds to the predetermined movement, and provide the first mode for the game based on the identification (or determination) that the movement of the electronic device (100) corresponds to the predetermined movement.

[0061] For example, since the predetermined movement of the electronic device (100) can be caused while looking at the screen (150) as in the state (291), the first input for providing the first mode for the game may not require a user state as in the state (292). For example, since the first input represented by the state (510) does not require a user state as in the state (292), the first input represented by the state (510) can enhance the convenience of the user playing the game. For example, since the predetermined movement of the electronic device (100) can be caused while causing a touch input on at least some of the second executable objects (210), the first input represented by the state (510) can enhance the convenience of the user playing the game.

[0062] For example, the first input may include a gesture input on the screen (120) of the electronic device (100), such as state (520). For example, the gesture input may be distinguished from a touch input on each of the plurality of executable objects (e.g., a tap (or single tap) input on each of the plurality of executable objects). For example, unlike the tap input, the gesture input may include a drag input (or swipe input) (or sweeping input) in which contact points on a portion of the screen (120) are moved and then released.

[0063] For example, unlike the touch input, the gesture input can be identified regardless of (or independently of) where the contact point starts on the screen (120) and where the contact point ends on the screen (120). For example, at least one processor (300) can identify a path of contact points having a length longer than a reference length, identify (or determine) whether the identified path corresponds to a predetermined path, and provide the first mode for the game based on the path corresponding to the predetermined path.

[0064] As a non-limiting example, the gesture input may be identified or recognized without utilizing identification of the start position and the end position of the path. For example, the gesture input may be caused while looking at the screen (150), such as state (291), because it does not require identification of the start position and the end position. For example, since the gesture input may be caused while looking at the screen (150), such as state (291), the first input represented by state (520) may not require a user state, such as state (292). For example, since the first input represented by state (520) does not require identification of the start position and the end position, the first input represented by state (520) may not require a user state, such as state (292). Since the first input represented by the state (520) does not require a user state such as the state (292), the first input represented by the state (520) can enhance the convenience of a user playing the game. For example, since the gesture input can be caused while causing a touch input on at least some of the second executable objects (210), the first input represented by the state (520) can enhance the convenience of a user playing the game.

[0065] For example, the first input may include an input of tapping the rear side of the housing assembly (535) of the electronic device (100) (or the rear exterior of the electronic device (100)) two or more times, such as in state (530). For example, the housing assembly (535) may include a memory (320), a communication circuit (310), a display (110) (e.g., including a window (or cover glass)), and at least one processor (300). For example, the housing assembly (535) may include a front side that is at least partially defined by the display (110) and a rear side that is opposite the front side.

[0066] For example, the first input, such as state (530), may represent an input defined for the rear side among the front side and the rear side. For example, at least one processor (300) may obtain data about the contact points through a sensor of the electronic device (100) configured to identify contact points occurring on the rear side, use the data to identify whether the contact points indicate that the rear sides have been tapped two or more times, and provide the first mode for the game based on the identification that the contact points indicate that the rear sides have been tapped two or more times.

[0067] For example, since tapping the rear side more than twice can be caused while looking at the screen (150) as in state (291), the first input for providing the first mode for the game may not require a user state such as state (292). Since the first input represented by state (530) does not require a user state such as state (292), the first input represented by state (530) can enhance the convenience of the user playing the game. For example, since tapping the rear side more than twice can be caused while causing a touch input on at least some of the second executable objects (210), the first input represented by state (530) can enhance the convenience of the user playing the game.

[0068] The first input illustrated in FIG. 5 is merely exemplary. The first input may include inputs other than those illustrated in FIG. 5. For example, the first input may include a voice input received through a microphone (not illustrated) of the electronic device (100). For example, at least one processor (300) may receive data regarding the voice input through the microphone, analyze the data to recognize the voice input, determine whether a predetermined keyword (e.g., the name of the first mode) is included in the voice input, and provide the first mode based on the voice input including the predetermined keyword. However, the present invention is not limited thereto.

[0069] Referring back to FIG. 4, at operation 440, at least one processor (300) may provide the first mode in response to a first input received while the screen (120) is being streamed to the external electronic device (130). For example, the first mode may be represented as a mode provided to execute one function among functions corresponding to each of the first executable objects (200) within the screen (120) while the user is in a state of viewing the screen (150), such as state (291). For example, the first mode may be represented as a mode provided to execute one function among functions corresponding to each of preset executable objects among the plurality of executable objects within the screen (120) while the user is in a state of viewing the screen (150), such as state (291).

[0070] For example, the first mode may be described as a mode provided to execute one of the functions corresponding to each of the first executable objects (200) within the screen (120) without requiring a user's state of looking at the screen (120), such as state (291). As a non-limiting example, the first mode may be represented as a mode for deactivating executable objects other than the preset executable objects among the plurality of executable objects.

[0071] For example, the first mode may be represented as a mode provided to execute the function more intuitively and / or more quickly than executing the function through a touch input that selects one of the first executable objects (200). For example, the first mode may be represented as a mode provided to execute the function more intuitively and / or more quickly than executing the function through a touch input that selects one of the preset executable objects.

[0072] For example, the first mode may be described as a mode in which an input more intuitive than the touch input can be received to execute the corresponding function more intuitively than a touch input for selecting one of the first executable objects (200). For example, the first mode may be described as a mode in which an input more intuitive than the touch input can be received to execute the corresponding function more intuitively than a touch input for selecting one of the preset executable objects.

[0073] For example, since the first mode is a mode that can receive more intuitive input than the touch input, the second executable objects (210) may be in an inactive state while providing the first mode. For example, the other executable objects may be in an inactive state while providing the first mode.

[0074] The second executable objects (210) that are deactivated while providing the first mode may be described and exemplified in more detail with reference to FIGS. 6a and 6b.

[0075] Figures 6a and 6b illustrate examples of a first mode for a game.

[0076] Referring to FIG. 6A, while at least one processor (300) provides the first mode, the second executable objects (210) among the first executable objects (200) and the second executable objects (210) may be deactivated. For example, at least one processor (300) may provide the first mode until one function among the functions corresponding to each of the first executable objects (200) is selected according to the second input.

[0077] As a non-limiting example, while at least one processor (300) provides the first mode, the preset executable objects and the other executable objects among the plurality of executable objects may be deactivated. For example, at least one processor (300) may provide the first mode until one function among the functions corresponding to the preset executable objects among the plurality of executable objects is selected according to the second input.

[0078] For example, an executable object (210-1) for changing the direction and / or movement of a player character while at least one processor (300) provides the first mode may be disabled. For example, the executable object (210-1) may be disabled to reduce the execution of a function (e.g., a function corresponding to one of the second executable objects (210)) that is not intended by the user based on an input (e.g., a third input and / or a second input as exemplified below) received within (or during) the first mode.

[0079] For example, since receiving the first input indicates activating the first mode (or changing the mode for the game from the second mode to the first mode) to execute a function corresponding to one of the first executable objects (200), at least one processor (300) may, in response to providing the first mode, deactivate the executable object (210-1).

[0080] For example, at least one processor (300) may change the state of the electronic device (100) from a state (600) of moving the player character in response to an input received through the executable object (210-1) to a state (610) of refraining from moving the player character in response to an input received through the executable object (210-1) based on activating the first mode in response to the first input.

[0081] For example, within state (610), at least one processor (300) may maintain the movement state of the player character even if it identifies contact points on the executable object (210-1). For example, within state (610), at least one processor (300) may maintain the movement state of the player character independently of the contact points based on the first mode provided in response to the first input, instead of changing the movement state of the player character based on the contact points. For example, within state (610), at least one processor (300) may maintain the player character stationary independently of identifying the contact points.

[0082] For example, an executable object (210-2) that provides a predefined action of the player character while at least one processor (300) provides the first mode may be deactivated. For example, the executable object (210-2) may be deactivated to reduce the execution of a function (e.g., a function corresponding to one of the second executable objects (210)) that is not intended by the user based on an input (e.g., a third input and / or a second input as exemplified below) received within (or during) the first mode.

[0083] For example, since receiving the first input indicates activating the first mode (or changing the mode for the game from the second mode to the first mode) to execute a function corresponding to one of the first executable objects (200), at least one processor (300) may, in response to providing the first mode, deactivate the executable object (210-2).

[0084] For example, at least one processor (300) may change the state of the electronic device (100) from a state in which the player character performs a predefined action in response to an input received through the executable object (210-2) to a state in which the action of the player character is maintained in response to an input received through the executable object (210-2), based on activating the first mode in response to the first input. For example, even if the at least one processor (300) identifies contact points on the executable object (210-2), based on activating the first mode in response to the first input, the player character may maintain the predetermined action and / or the cessation of the predetermined action.

[0085] For example, at least one processor (300) may, based on activating the first mode, refrain from changing a state associated with the player character, such as changing to an auto-attack state that involves movement of the player character, actions against other player characters, and / or actions against non-player characters, even if the processor identifies contact points on the executable object (210-2). For example, at least one processor (300) may, based on activating the first mode, maintain the state of the player character within the auto-attack state even if the processor identifies contact points on the executable object (210-2).

[0086] For example, while at least one processor (300) provides the first mode, an executable object (210-3) for providing actions of the player character applied to other player characters and / or non-player characters may be disabled. For example, the executable object (210-3) may be disabled to reduce the execution of functions (e.g., functions corresponding to one of the second executable objects (210)) that are not intended by the user based on inputs (e.g., the third input and / or the second input exemplified below) received within (or during) the first mode.

[0087] For example, since receiving the first input indicates activating the first mode (or changing the mode for the game from the second mode to the first mode) to execute a function corresponding to one of the first executable objects (200), at least one processor (300) may, in response to providing the first mode, deactivate the executable object (210-3).

[0088] For example, at least one processor (300) may change the state of the electronic device (100) from state (620) to state (630) based on activating the first mode in response to the first input. For example, state (630) may be described as a state in which a player character performs an action on another player character and / or a non-player character in response to an input received through an executable object (210-3). For example, state (630) may be described as a state in which a player character does not perform an action on another player character and / or a non-player character in response to an input received through an executable object (210-3).

[0089] For example, within state (630), at least one processor (300) may refrain from an attack motion of the player character even if it identifies contact points on the executable object (210-3). For example, within state (630), at least one processor (300) may maintain the stationary state of the player character independently of identifying the contact points.

[0090] For example, while at least one processor (300) provides the first mode, the executable object (210-4) for the player character to acquire a virtual item within the game may be deactivated. For example, the executable object (210-4) may be deactivated to reduce the execution of a function (e.g., a function corresponding to one of the second executable objects (210)) that is not intended by the user based on an input (e.g., a third input and / or a second input as exemplified below) received within (or during) the first mode.

[0091] For example, since receiving the first input indicates activating the first mode (or changing the mode for the game from the second mode to the first mode) to execute a function corresponding to one of the first executable objects (200), at least one processor (300) may, in response to providing the first mode, deactivate the executable object (210-4).

[0092] For example, at least one processor (300) may, based on activating the first mode in response to the first input, change the state of the electronic device (100) from a state in which the player character acquires a virtual item based on an input received through the executable object (210-4) to a state in which the player character refrains from acquiring a virtual item based on an input received through the executable object (210-1). For example, within the state in which the player character refrains from acquiring a virtual item, even if the at least one processor (300) identifies contact points on the executable object (210-4), the virtual item may not be added to the inventory of the player character. For example, within the state, the at least one processor (300) may maintain a state in which the player character holds the virtual item independently of identifying the contact points.

[0093] Referring to FIG. 6B, for example, while at least one processor (300) provides the first mode, the shape (or form) of the second executable objects (210) among the first executable objects (200) and the second executable objects (210) may be changed. For example, the shape of the second executable objects (210) may be changed to indicate that the second executable objects (210) are deactivated in accordance with providing the first mode.

[0094] For example, at least one processor (300) may, in response to providing the first mode, change the state of the second executable objects (210) among the first executable objects (200) and the second executable objects (210) to a blurred state.

[0095] For example, at least one processor (300) may increase the transparency of the second executable objects (210) in response to providing the first mode. For example, as in state (650), while at least one processor (300) provides the first mode, the state of the second executable objects (210) among the first executable objects (200) and the second executable objects (210) may be changed to a translucent state. For example, at least one processor (300) may stop displaying the second executable objects (210) by changing the value of the transparency of the second executable objects (210) to a maximum value while providing the first mode, as in state (640).

[0096] For example, at least one processor (300) may change a portion of the shape of each of the second executable objects (210) among the first executable objects (200) and the second executable objects (210) while providing the first mode. For example, at least one processor (300) may change the type of a line defining the outline of each of the second executable objects (210) from a solid line to a dotted line, such as in the state (660), while providing the first mode.

[0097] While providing the first mode, as shown in FIG. 6B, the state of the second executable objects (210) is merely exemplary. For example, while providing the first mode, the brightness of the second executable objects (210) among the first executable objects (200) and the second executable objects (210) may be changed. For example, while providing the first mode, the second executable objects (210) among the first executable objects (200) and the second executable objects (210) may be dimmed.

[0098] As a non-limiting example, at least one processor (300) may, in response to providing the first mode, display visual affordances on the display (110). For example, the visual affordances may be displayed to assist in executing a function corresponding to one of the first executable objects (200). For example, the visual affordances may be displayed as an overlay on the screen (120). For example, the visual affordances may be displayed to assist in executing a function corresponding to one of the first executable objects (200) while the user looks at the screen (150), such as in state (291). For example, the visual affordances may be displayed as an overlay on the screen (120) to allow the user to execute a function corresponding to one of the first executable objects (200) without looking at the screen (120), such as in state (292).

[0099] For example, the visual affordances displayed as an overlay on the screen (120) may be streamed to the external electronic device (130) according to the execution of at least one processor (300). For example, visual affordances (e.g., corresponding to the visual affordances displayed as an overlay on the screen (120)) may be displayed as an overlay on the screen (150) according to the first mode. The visual affordances are described and exemplified in more detail with reference to FIG. 7A.

[0100] Figures 7a and 7b illustrate examples of visual affordances displayed according to the first mode for the game.

[0101] Referring to FIG. 7A, in state (701), at least one processor (300) may display visual affordances (710) (e.g., corresponding to visual affordances (720) streamed from the electronic device (100) to the external electronic device (130)) as an overlay on the screen (120) based on providing the first mode. For example, the visual affordances (710) may be displayed as an overlay on the screen (120).

[0102] For example, the first executable objects (200) may be included in a plurality of groups. For example, a first part of the first executable objects (200) may be included in a first group among the plurality of groups, a second part of the first executable objects (200) may be included in a second group different from the first group among the plurality of groups, a third part of the first executable objects (200) may be included in a third group different from the first group and the second group among the plurality of groups, and a fourth part of the first executable objects (200) may be included in a fourth group different from the first group, the second group, and the third group among the plurality of groups.

[0103] As a non-limiting example, the plurality of groups may be defined based on the locations of the first executable objects (200). For example, the first part of the first executable objects (200) included in the first group may be adjacent to a first edge area of ​​the screen (120) (or located around the first edge area of ​​the screen (120), the second part of the first executable objects (200) included in the second group may be adjacent to a second edge area of ​​the screen (120), the third part of the first executable objects (200) included in the third group may be adjacent to a third edge area of ​​the screen (120), and the fourth part of the first executable objects (200) included in the fourth group may be adjacent to a fourth edge area of ​​the screen (120).

[0104] For example, the visual affordances (710) may include a visual affordance (710-1) for guiding or inducing an input to access a function corresponding to the first part of the first executable objects (200). For example, the visual affordances (710) may include a visual affordance (710-2) for guiding or inducing an input to access a function corresponding to the second part of the first executable objects (200). For example, the visual affordances (710) may include a visual affordance (710-3) for guiding or inducing an input to access a function corresponding to the third part of the first executable objects (200). For example, the visual affordances (710) may include a visual affordance (710-4) for guiding or inducing an input to access a function corresponding to the fourth part of the first executable objects (200).

[0105] For example, the visual affordance (710-1) may be positioned in a first direction toward the first edge region to guide an input to access a function corresponding to the first part of the first executable objects (200).

[0106] For example, the visual affordance (710-2) may be positioned in a second direction (e.g., perpendicular to the first direction) toward the second edge region to guide an input to access a function corresponding to the second portion of the first executable objects (200).

[0107] For example, the visual affordance (710-3) may be positioned in a third direction (e.g., perpendicular to the first direction and opposite to the second direction) toward the third edge region to guide an input to access a function corresponding to the third portion of the first executable objects (200).

[0108] For example, the visual affordance (710-4) may be positioned in a fourth direction (e.g., opposite to the first direction and perpendicular to the second direction and the third direction) toward the fourth edge region to guide an input to access a function corresponding to the fourth portion of the first executable objects (200).

[0109] For example, at least one processor (300) may display visual objects corresponding to the first part of the first executable objects (200) represented by the visual affordance (710-1) based on a first drag input (e.g., the third input exemplified below) in a direction corresponding to the first direction.

[0110] For example, at least one processor (300) may display visual objects corresponding to the second portion of the first executable objects (200) represented by the visual affordance (710-2) based on a second drag input (e.g., a third input as exemplified below) in a direction corresponding to the second direction.

[0111] For example, at least one processor (300) may display visual objects corresponding to the third portion of the first executable objects (200) represented by the visual affordance (710-3) based on a third drag input (e.g., the third input exemplified below) in a direction corresponding to the third direction.

[0112] For example, at least one processor (300) may display visual objects corresponding to the fourth portion of the first executable objects (200) represented by the visual affordance (710-4) based on a fourth drag input (e.g., the third input exemplified below) in a direction corresponding to the fourth direction. These operations will be described and exemplified in more detail below.

[0113] Referring to FIG. 7B, in state (702), at least one processor (300) may display a screen (730) including visual affordances (710) on the display (110) based on providing the first mode. For example, the screen (730) including visual affordances (710) may be distinct from the screen (150). For example, the screen (730) including visual affordances (710) may be independent from the screen (150).

[0114] Referring again to FIG. 4, at operation 450, at least one processor (300) may receive the second input while the at least one processor (300) provides the first mode. For example, the second input may be represented as an input that causes the electronic device (100) to execute a function corresponding to one of the first executable objects (200) while providing the first mode for a game.

[0115] For example, the second input may be represented as an input that causes the electronic device (100) to execute a function corresponding to one of the preset executable objects among the plurality of executable objects while providing the first mode for the game.

[0116] For example, the second input may represent an input that causes the electronic device (100) to execute a function corresponding to one of the first executable objects (200) in a state in which the user looks at the screen (150) of the external electronic device (130), such as in the state (291), while providing the first mode for a game. For example, the second input may represent an input that causes the electronic device (100) to execute a function corresponding to one of the first executable objects (200) in a state in which the user does not look at the screen (120) of the electronic device (100), such as in the state (291), while providing the first mode for a game. For example, the second input may include a touch input on the first executable object. For example, the second input may include an input of a preset gesture.

[0117] For example, the second input may represent an input that causes the electronic device (100) to execute a function corresponding to one of the preset executable objects among the plurality of executable objects while the user is not looking at the screen (120) of the electronic device (100), such as in state (291), while providing the first mode for the game. For example, the second input may include a touch input on the preset executable objects.

[0118] As a non-limiting example, the second input may include a scrolling input for selecting a visual object. For example, the second input may include an input in which a contact point on a display (110) of the electronic device (100) is moved. For example, at least one processor (300) may identify a path defined by the movement of the contact point and cause the screen (120) to move in a second direction opposite to the first direction in which the contact point is moved based on the path.

[0119] For example, the second input may be more intuitive than an input for executing a function corresponding to one of the first executable objects (200) on the screen of the second mode for the game. As a non-limiting example, the second input may be received after a third input is received in response to one of the visual affordances (710) displayed based on providing the first mode for the game. The third input and the second input are described and illustrated in more detail with reference to FIG. 8A.

[0120] Figures 8a, 8b, 8c, and 8d illustrate examples of third inputs received for visual affordances displayed according to a first mode for a game.

[0121] Referring to FIG. 8A, at least one processor (300) may display visual affordances (710) on the screen (120) within a state (800). For example, at least one processor (300) may receive a drag input in a direction indicated by the visual affordance (710-2) within the state (800). For example, in response to the drag input, at least one processor (300) may change the state (800) to the state (820).

[0122] For example, within state (820), at least one processor (300) may stop displaying visual affordances (710). For example, within state (820), at least one processor (300) may display overlapping visual objects (821) on the screen (120).

[0123] For example, the visual objects (821) may each represent functions within the second group represented by the visual affordance (710-2). For example, a visual object (821-1) among the visual objects (821) may be overlapped on a first portion (822) of the screen (120). For example, a visual object (821-2) among the visual objects (821) may be overlapped on a second portion (824) of the screen (120). For example, a visual object (821-3) among the visual objects (821) may be overlapped on a third portion (823) of the screen (120). For example, a visual object (821-4) among the visual objects (821) may be overlapped on a fourth portion (825) of the screen (120).

[0124] For example, within the state (820), at least one processor (300) may receive a tap input for selecting a visual object (821-3) among the visual objects (821) as the second input. For example, in response to the tap input, at least one processor (300) may change the state (820) to the state (840). For example, within the state (840), at least one processor (300) may display a window (845) containing information about items owned by the player character in response to the tap input.

[0125] For example, the window (845) can be overlapped on the screen (120). For example, the electronic device (100) can provide the window (845) displayed based on receiving a tap input for an executable object (200-4) among the first executable objects (200) displayed in the state (610) in response to a third input (e.g., a drag input corresponding to the visual affordance (710-2)) and a second input following the third input (e.g., a tap input for the visual object (821-3)). For example, since the third input and the second input can be caused without the user looking at the screen (120) as in the state (292), the electronic device (100) can enhance the user experience for the game by displaying the window (845) according to the third input and the second input following the third input.

[0126] As another example, at least one processor (300) may display visual affordances (710) on the screen (120) within a state (800). For example, at least one processor (300) may receive a drag input in a direction indicated by the visual affordance (710-2). For example, at least one processor (300) may change the state (800) to the state (830) in response to the drag input.

[0127] For example, within state (830), at least one processor (300) may stop displaying visual affordances (710). For example, within state (830), at least one processor (300) may display overlapping visual objects (831) on the screen (120).

[0128] For example, the visual objects (831) may each represent functions within the second group represented by the visual affordance (710-2). For example, a visual object (831-1) among the visual objects (831) may be overlapped on a first part (832) of the screen (120). For example, a visual object (831-2) among the visual objects (831) may be overlapped on a second part (834) of the screen (120). For example, a visual object (831-3) among the visual objects (831) may be overlapped on a third part (833) of the screen (120). For example, a visual object (831-4) among the visual objects (831) may be overlapped on a fourth part (835) of the screen (120).

[0129] For example, within the state (830), at least one processor (300) may receive as the second input a drag input (or swipe input) (or sweeping input) in which contact points on a portion of the screen (120) are moved and then released for selecting a visual object (831-3) among the visual objects (831). For example, in response to the drag input, at least one processor (300) may change the state (830) to the state (840). For example, within the state (840), at least one processor (300) may display, in response to the drag input, a window (845) containing information about items owned by the player character.

[0130] For example, the window (845) can be overlapped on the screen (120). For example, the electronic device (100) can provide the window (845) displayed based on receiving a tap input for an executable object (200-4) among the first executable objects (200) displayed in the state (610) in response to the third input (e.g., a drag input corresponding to the visual affordance (710-2)) and the second input following the third input (e.g., a tap input for the visual object (831-3)). For example, since the third input and the second input can be caused without the user looking at the screen (120) as in the state (292), the electronic device (100) can enhance the user experience for the game by displaying the window (845) according to the third input and the second input following the third input.

[0131] Referring to FIG. 8B, at least one processor (300) may display visual affordances (710) on the screen (120) within a state (800). For example, at least one processor (300) may receive a drag input in a direction indicated by the visual affordance (710-1) within the state (800). For example, in response to the drag input, at least one processor (300) may change the state (800) to the state (860).

[0132] For example, within state (860), at least one processor (300) may stop displaying visual affordances (710). For example, within state (860), at least one processor (300) may, in response to the drag input, display a window (850) containing a map of the environment within the game.

[0133] For example, the window (850) may include an expanded-size map (851) of the environment within the game and an indicator (852) superimposed on the map (851). For example, the indicator (852) may indicate a geographical area within the game for movement of the player character. For example, the window (850) may be superimposed on the screen (120). For example, the electronic device (100) may provide the window (850) displayed based on receiving a tap input for an executable object (200-1) among the first executable objects (200) displayed within the state (610) in response to the second input (e.g., a drag input for the visual affordance (710-1)). For example, since the second input can be caused without the user looking at the screen (120) as in the state (292), the electronic device (100) can enhance the user experience for the game by displaying the window (850) according to the second input.

[0134] Referring to FIG. 8C, at least one processor (300) may display visual affordances (710) on the screen (120) within a state (800). For example, at least one processor (300) may receive a drag input in a direction indicated by the visual affordance (710-2) within the state (800). For example, in response to the drag input, at least one processor (300) may change the state (800) to the state (870).

[0135] For example, within state (870), at least one processor (300) may stop displaying visual affordances (710). For example, within state (870), at least one processor (300) may display overlapping visual objects (871) on the screen (120).

[0136] For example, visual objects (871) may each represent functions within the second group represented by visual affordance (710-2). For example, visual objects (871) may be displayed horizontally aligned on the screen (120).

[0137] For example, within the state (870), at least one processor (300) may receive, as the second input, a scrolling input in which contact points on a visual object (875) of the screen (120) for selecting a visual object (871-3) among the visual objects (871) are moved and then released. For example, when the contact points on the visual object (875) are moved, the at least one processor (300) may move the visual objects (871) in the direction in which the visual object (875) moves. For example, when the contact points on the visual object (875) are moved and then released, the visual object (871-3) displayed on the portion (876) of the screen (120) may be selected. For example, in response to the scrolling input, the at least one processor (300) may change the state (870) to the state (840).

[0138] For example, within state (840), at least one processor (300) may, in response to the drag input, display a window (845) containing information about items owned by the player character.

[0139] For example, the window (845) can be overlapped on the screen (120). For example, the electronic device (100) can provide the window (845) displayed based on receiving a tap input for an executable object (200-4) among the first executable objects (200) displayed in the state (610) in response to a third input (e.g., a drag input corresponding to the visual affordance (710-2)) and a second input following the third input (e.g., a tap input for the visual object (821-3)). For example, since the third input and the second input can be caused without the user looking at the screen (120) as in the state (292), the electronic device (100) can enhance the user experience for the game by displaying the window (845) according to the third input and the second input following the third input.

[0140] Referring to FIG. 8d, in state (880), at least one processor (300) can display a screen (881) including visual objects (871) on the display (110). For example, the screen (881) including visual objects (871) can be distinguished from the screen (150). For example, the screen (881) including visual objects (871) can be independent from the screen (150).

[0141] The screen (881) shown in the state (880) of FIG. 8d is merely exemplary. For example, at least one processor (300) may display a screen including visual objects (821) on the display (110). For example, the screen including visual objects (821) may be distinguished from the screen (150).

[0142] For example, at least one processor (300) may display a screen including visual objects (831) on the display (110). For example, the screen including visual objects (831) may be distinguished from the screen (150), but is not limited thereto.

[0143] Referring again to FIG. 4, at operation 460, at least one processor (300) may change the mode for the game from the first mode to the second mode. For example, within state (840) or state (860), at least one processor (300) may change the mode for the game from the first mode to the second mode. For example, at least one processor (300) may, in response to the second input, stop or terminate providing the first mode. As a non-limiting example, at least one processor (300) may, in response to the second input, execute the function selected from among the functions corresponding to the preset executable objects among the plurality of executable objects according to the second input.

[0144] For example, while at least one processor (300) provides the second mode, the first executable objects (200) and the second executable objects (210) may be activated. For example, the second mode may be described as a general state in which a user plays a game, such as state (600) or state (620). For example, while at least one processor (300) provides the second mode, the electronic device (100) may be caused to execute a function corresponding to the one executable object that received the tap input based on receiving a tap input for one of the plurality of executable objects displayed within state (600) or state (620).

[0145] For example, within state (600), while at least one processor (300) provides the second mode, at least one processor (300) may change the direction and / or movement of the player character based on receiving a touch input to an executable object (210-1). For example, while at least one processor (300) provides the second mode, at least one processor (300) may cause the player character to perform a predefined action based on receiving a touch input to an executable object (210-2).

[0146] For example, within state (620), while at least one processor (300) provides the second mode, at least one processor (300) may cause the player character to perform an action applied to another player character and / or a non-player character based on receiving a touch input to an executable object (210-3). For example, while at least one processor (300) provides the second mode, at least one processor (300) may cause the player character to acquire a virtual item based on receiving a touch input to an executable object (210-4). As a non-limiting example, another input distinct from the second input may be defined within the electronic device (100) (and / or within the game) to change the mode for the game from the first mode to the second mode. For example, changing the mode for the game from the first mode to the second mode may be performed by re-receiving the first input. Changing the mode for the game from the first mode to the second mode by re-receiving the first input is described and illustrated in more detail with reference to FIG. 9.

[0147] FIG. 9 illustrates an example of a first input received to change the mode for a game from a first mode to a second mode.

[0148] Referring to FIG. 9, while at least one processor (300) provides the first mode, the electronic device (100) may receive the first input. For example, while at least one processor (300) provides the first mode, the electronic device (100) may receive the first input again before the second input is received. For example, in response to the re-received first input, the at least one processor (300) may cause the mode for the game to be changed from the first mode to the second mode.

[0149] For example, within state (910), while at least one processor (300) provides the first mode, an input of tapping the rear side of the housing assembly (535) of the electronic device (100) two or more times, such as state (530), may be received again. For example, while at least one processor (300) provides the first mode, while at least one processor (300) provides the first mode, the state (910) may be changed to state (600) in response to an input of tapping the rear side of the housing assembly (535) of the electronic device (100) two or more times, such as state (530).

[0150] For example, at least one processor (300) may cause the electronic device (100) to stop or terminate providing the first mode in response to an input of tapping the rear side of the housing assembly (535) of the electronic device (100) two or more times, such as in state (530). For example, within state (600), at least one processor (300) may cause the electronic device (100) to change the mode for a game from the first mode to the second mode in response to an input of tapping the rear side of the housing assembly (535) of the electronic device (100) two or more times, such as in state (530).

[0151] The first input represented by Fig. 9 is merely exemplary.

[0152] The first input may include an input other than that shown in FIG. 9.

[0153] For example, at least one processor (300) may, while providing the first mode, receive again an input identifying a predetermined movement of the electronic device (100) via a sensor configured to obtain data about movement of the electronic device (100), such as state (510). For example, at least one processor (300), while providing the first mode, may obtain data representing movement of the electronic device (100) via the sensor, identify (or determine) whether the movement of the electronic device (100) represented by the data corresponds to the predetermined movement, and provide the second mode for the game based on the identification (or determination) that the movement of the electronic device (100) corresponds to the predetermined movement.

[0154] For example, at least one processor (300) may obtain data indicating movement of the electronic device (100) through the sensor, identify (or determine) whether the movement of the electronic device (100) indicated by the data corresponds to the predetermined movement, and stop or terminate providing the first mode based on the identification (or determination) that the movement of the electronic device (100) corresponds to the predetermined movement.

[0155] For example, while providing the first mode, at least one processor (300) may cause the electronic device (100) to receive the gesture input again on the screen (120) of the electronic device (100) as in the state (520). For example, while providing the first mode, at least one processor (300) may identify a path of contact points having a length longer than a reference length, identify (or determine) whether the identified path corresponds to a predetermined path, and provide the second mode for the game based on the path corresponding to the predetermined path. For example, based on the gesture input, at least one processor (300) may stop or terminate providing the first mode.

[0156] For example, while at least one processor (300) provides the first mode, changing the first mode to the second mode in response to the first input can enhance the convenience of a user playing the game because the first input can be more intuitive compared to other inputs.

[0157] As a non-limiting example, changing the mode for the game from the first mode to the second mode may be performed based on identifying that no input has been received for a reference period of time within a state providing the first mode. For example, changing the mode for the game from the first mode to the second mode in response to input not being received for the reference period of time is described and illustrated in more detail with reference to FIG. 10.

[0158] FIG. 10 illustrates an example of changing the mode for a game from a first mode to a second mode based on a second input that is not received during a reference time while at least one processor provides a first mode for the game.

[0159] Referring to FIG. 10, at least one processor (300) may, while providing the first mode, identify whether the second input is received during a reference time since the first input was received. For example, while providing the first mode, at least one processor (300) may change the mode for a game of the electronic device (100) from the first mode to the second mode based on the second input not being received during the reference time. For example, while providing the first mode, at least one processor (300) may, while providing the first mode, stop or terminate providing the first mode based on the second input not being received during the reference time. For example, at least one processor (300) may change the state (610) to the state (600) based on the second input not being received during the reference time.

[0160] Referring back to FIG. 4 , at operation 460, at least one processor (300) may respond to the second input while the screen (120) is being streamed to the external electronic device (130) and providing the first mode. For example, at least one processor (300) may execute a function selected from among functions corresponding to the first executable objects (200) in response to the second input. For example, as in state (840), at least one processor (300) may display a window (845) containing information about items owned by the player character as an overlay on the screen (120) in response to the second input. For example, at least one processor (300) may provide, in response to the second input, a window (845) that is displayed based on receiving a tap input for an executable object (200-4) among the first executable objects (200) displayed in state (600).

[0161] FIG. 11 illustrates an example of interconnected servers and one or more user terminals (e.g., user terminals (1110, 1120, 1130, 1140, 1150)) to provide a game service.

[0162] A server (e.g., servers (1160, 1170)) may include a computer designed to provide server functionality, such as a workstation. Embodiments are not limited thereto, and a server may include a personal computer configured to run a software application, and / or a combination of such personal computers. A server may include a group (or cluster) of the example workstations and / or personal computers.

[0163] In one embodiment, a service provider may provide or operate an automated service using a server. The service may include a game service. The game service may be provided for network-based playing of games such as role-playing games (RPGs), massive multi-user online RPGs (MMORPGs), first-person shooters (FPSs), and / or puzzle games. Through the game service, different users (e.g., users of the game service) may connect with each other over a network, cooperate, or compete. The server may support or execute functions related to the game service (e.g., matching users, providing a virtual space (1100) such as a battlefield, trading virtual items such as a market, and / or chatting between users).

[0164] Referring to FIG. 11, servers (1160, 1170) included in a network are illustrated to provide different services. The first server (1160) may be configured to relay a user's connection with various game services provided through the network (e.g., a game service provided by the second server (1170). The services provided through the first server (1160) may be referred to as a game platform service, a game launching service, a game publishing service, and / or a game relay service.

[0165] Referring to FIG. 11, a first server (1160) may cause a second server (1170) for providing a game service to provide a user experience related to the game service to users of the game platform service. The first server (1160) may store, in a user database related to users of the game platform service, information indicating one or more game services to which the users have subscribed. The information may further include information for the first server (1160) to access another server for the game service, such as the second server (1170), (e.g., account information for logging into the game service, and / or authentication information).

[0166] Referring to FIG. 11, the first server (1160) may store information indicating at least one game service subscribed by users of the game platform service in a user database. The user database may include records representing users subscribed to the game platform service. The records may include at least one game service subscribed by the corresponding user and / or information for accessing (or logging in to) the at least one game service.

[0167] Referring to FIG. 11, users (U1, U2) of a game platform service provided by a first server (1160) are illustrated. A user (U1) possessing user terminals (1110, 1120, 1130) and a user (U2) possessing user terminals (1140, 1150) are illustrated, but the number of users of the first server (1160) and the number of user terminals possessed by each of the users are not limited thereto. Users of the game platform service may be referred to as users.

[0168] Referring to FIG. 11, various appearances of a user terminal (or user equipment) are illustrated. The user terminal may include a smartphone (e.g., user terminals (1110, 1150)), a smartpad, and / or a tablet PC. The user terminal may include a personal computer such as a desktop (e.g., user terminals (1120, 1140)) and a laptop. The user terminal may include a portable gaming device dedicated to a game service (e.g., user terminal (1130)) and / or a gaming console. The user terminal may include a smart accessory such as a smartwatch and / or a head-mounted device (HMD). Embodiments of the user terminal are not limited thereto.

[0169] Referring to FIG. 11, a user (U1) can access a game platform service provided by a first server (1160) using at least one of the user terminals (1110, 1120, 1130). Similarly, a user (U2) can access the game platform service using at least one of the user terminals (1140, 1150). A software application for communicating with the first server (1160) can be installed on at least one of the user terminals (1110, 1120, 1130, 1140, 1150). The software application can be referred to as a game platform application, a game platform program, a game launcher, and / or a client application.

[0170] Hereinafter, the connection relationship between the user terminal (1110), which is one of the user terminals (1110, 1120, 1130, 1140, 1150), and the first server (1160) and the user terminal (1110) and the second server (1170) will be described.

[0171] For example, a user (U1) can access a game platform service provided by a first server (1160) using a user terminal (1110) that has executed a game launcher. The user terminal (1110) that has executed the game launcher can establish a communication link (L1) between the user terminal (1110) and the first server (1160). The communication link (L1) can include a logical connection (e.g., a logical connection distinguished by a session) established for data communication between the user terminal (1110) and the first server (1160) within a network. Similarly, in response to an input from a user (U2) to execute a game launcher on the user terminal (1140), the user terminal (1140) can establish a communication link (L2) between the first server (1160) and the user terminal (1140).

[0172] The first server (1160), which detects a user terminal (1110) that has executed a game launcher using a communication link (L1), can verify a user account logged into the user terminal (1110). By comparing a user database stored in the first server (1160) with authentication information (e.g., ID, password, PIN (personal identification number), and / or OTP (one-time password)) transmitted from the user terminal (1110), the first server (1160) can authenticate the user (U1) that has executed the game launcher on the user terminal (1110). Based on the authentication, the user terminal (1110) can display a screen provided by the game launcher. For example, the state of the user terminal (1110) that executes the game launcher can include a state before authenticating the user (U1) (e.g., a locked state and / or a state before logging in) and a state after authenticating the user (U1).

[0173] Referring to FIG. 11, when users (U1, U2) of user terminals (1110, 1140) connected to a first server (1160) via communication links (L1, L2) are authenticated, the first server (1160) can support interaction between the users (U1, U2). For example, the first server (1160) can support transmission (e.g., streaming) and / or reception of messages (e.g., text messages), images, videos, sounds (e.g., voice chat), and / or posts between the users (U1, U2). The first server (1160) configured to provide a game platform service can execute or support functions related to online activities of users (U1, U2) related to games.

[0174] When accessing a game platform service using a user terminal (1110), the user (U1) can access a game service connected to the game platform service. For example, a user terminal (1110) running a game launcher can receive an input for accessing a game service. In response to the input for accessing a game service detected using the game launcher, the user terminal (1110) can transmit a signal related to the input to a first server (1160) via a communication link (L1). The first server (1160) that receives the signal can communicate with a second server (1170) that provides the game service indicated by the signal. For example, using a communication link (L3) established between servers (1160, 1170), a first server (1160) can transmit information related to a user (U1) logged in to a game platform service (e.g., authentication information required for a second server (1170) providing a game service to authenticate the user (U1). Based on the authentication of the user (U1) using the information, a communication link (L4) between the user terminal (1110) of the user (U1) and the second server (1170) can be established.

[0175] Similarly, the first server (1160) may receive a signal from the user terminal (1140) where the user (U2) is logged in, notifying the reception of an input for accessing the game service. The first server (1160) receiving the signal may transmit a signal to the second server (1170) using the communication link (L2), causing the establishment of a communication link (L5) between the user terminal (1140) and the second server (1170). Direct communication between the user terminal (1140) and the second server (1170) may be performed through the communication link (L5) established by the signal. The embodiment is not limited thereto, and indirect communication between the second server (1170) providing the game service and the user terminal (1140) may be performed using the communication links (L2, L3).

[0176] As described above, in a state where communication links (L4, L5) are established between the user terminals and the second server (1170) so that the game service is provided to the user terminals (e.g., user terminals (1110, 1140)) of each of the users (U1, U2), the second server (1170) for providing the game service can transmit information about at least a part of the virtual space (1100) to each of the user terminals. For example, the second server (1170) can transmit information (e.g., information for rendering the part of the virtual space (1100)) related to a part of the virtual space (1100) including a location (A) associated with the user (U1) to the user terminal (1110) of the user (U1). For example, the second server (1170) can transmit information related to another part of the virtual space (1100) including a location (B) associated with the user (U2) to the user terminal (1140) of the user (U2).

[0177] Although an exemplary operation has been described in which a user (e.g., users (U1, U2)) accesses a game service using a first server (1160) that provides a game platform service, the embodiment is not limited thereto. For example, a user may directly access a second server (1170) for a game service without the first server (1160) using a game application installed on a user terminal.

[0178] Hereinafter, exemplary operations of a user terminal and / or a server associated with a communication link connected for a game service and / or a game platform service are described with reference to FIGS. 12A and 12B . For example, exemplary operations of a first server (1160) based on a user (U1) and a user terminal (1120) are described, but the embodiment is not limited thereto.

[0179] FIGS. 12A, 12B, and 12C illustrate exemplary cases of providing a game-related user experience using multiple user terminals (e.g., user terminals (1110, 1120)).

[0180] Referring to FIGS. 12A to 12C, an exemplary state in which communication links (L1, L3, L4) are established between a first server (1160) for a game platform service, a second server (1170) for a game service, and a user terminal (1120) is illustrated. The first server (1160) can communicate with the second server (1170) according to the operation described with reference to FIG. 11, thereby establishing a communication link (L4) between the second server (1170) and the user terminal (1120). For communication between the first server (1160) and the user terminal (1120), a game launcher related to the game platform service can be executed on the user terminal (1120).

[0181] Referring to FIGS. 12A to 12C, a user terminal (1120) that executes a game launcher can execute a game application in response to an input for executing the game application. The user terminal (1120) that executes the game application can display a screen (1200) provided by the game application. An exemplary screen (1200) including a player character (PC) (1210) controllable by an input received through the user terminal (1120) is illustrated, but the embodiment is not limited thereto. Using a signal received from a second server (1170) through a communication link (L4), the user terminal (1120) can display a screen (1200) including a PC (1210) included in a virtual space (1100).

[0182] Referring to FIG. 12A, a user terminal (1120) executing a game application can output a screen (1200) to a user (U1) and receive an input related to the game (e.g., an input for controlling a PC (1210)) from the user (U1). The user terminal (1120) that has received the input can transmit a first signal representing the input to a second server (1170) via a communication link (L4). The user terminal (1120) can further receive a second signal representing a virtual space (1100) and / or a state of the PC (1210) changed by the input from the second server (1170) via the communication link (L4). The user terminal (1120) that has received the second signal can at least partially change the screen (1200). For example, the user terminal (1210) can play an animation related to the PC (1210) within the screen (1200).

[0183] When an input for executing a game application is received through a game launcher, the user terminal (1120) can execute the game application in conjunction with the game launcher. Using the conjunction, the user terminal (1120) can execute a function of the game launcher based on the status of the game application. The function may include an operation of transmitting a signal notifying the status to a first server (1160) (e.g., streaming of a screen (1200) for live broadcasting). The function may include a remote play function of the game application executed on the user terminal (1120) using a user terminal different from the user terminal (1120).

[0184] Referring to FIG. 12B, user terminals (1110, 1120) connected to each other for remote play functionality are illustrated. The user terminals (1110, 1120) may be connected via a short-range wireless communication protocol such as Wi-Fi Direct and / or Bluetooth. The embodiment is not limited thereto, and the user terminals (1110, 1120) may be connected to each other via a cellular protocol such as long-term evolution (LTE), 5G new radio (NR), 6G, and / or above-6G. It is assumed that a game launcher is installed on all user terminals (1110, 1120), and authentication of a user (U1) on each of the user terminals (1110, 1120) based on the game launcher is completed.

[0185] When a game application is executed on a user terminal (1110) with relatively limited resources, such as a smartphone, the quality of the user experience related to the game may be reduced. The quality may be evaluated by indicators such as frames-per-second (fps), response delay, and / or resolution. The quality of the user experience may be better when the game application is executed on a desktop user terminal (1120) than when the game application is executed on the user terminal (1110). Referring to FIG. 12B, the user terminal (1120) may transmit a screen (1200) generated (or rendered) by a processing circuit (e.g., a GPU (graphics processing unit)) of the user terminal (1120) to the user terminal (1110). The operation of transmitting the screen (1200) may include an operation of transmitting a bitstream representing the screen (1200) via a communication link (L6) (e.g., streaming).

[0186] In the exemplary state of FIG. 12b where the user terminal (1120) displays the screen (1200) on the user terminal (1110), the user terminal (1110) can display the screen (1200) on the display based on the execution of the game launcher. For example, the user terminal (1110) can display the screen (1200) related to the game service provided by the second server (1170) on the display without installing and / or executing a game application for communicating with the second server (1170). The user terminal (1110) can display the screen (1200) provided by the user terminal (1120) based on the execution of the game launcher.

[0187] Referring to FIG. 12B, in one embodiment where the user terminal (1120) generates a screen (1200) to be displayed by the user terminal (1110), the user terminal (1120) may display a screen (1200) including a UI related to the user terminal (1110), which is a smart phone. The UI may include a virtual joystick including a visual object (1240) having a shape of a circle that can be dragged (or moved) by a touch input on an area (1230) having a shape of a circle. The UI may include a group (1250) of touchable visual objects that can control the state of the PC (1210). Comparing FIG. 12A and FIG. 12B, the screen (1200) of FIG. 12A, which is displayed through the display of the user terminal (1120), which is a desktop, may not include the visual object (1240) and / or the group (1250). In a state where a screen (1200) is transmitted to a user terminal (1110) which is a smartphone, the user terminal (1110) that receives the screen (1200) can overlap an area (1230) including a visual object (1240) and a group (1250) on the screen (1200). For example, the screen (11200) displayed on the display of the user terminal (1110) can further include a visual object (1240), an area (1230), and a group (1250) for guiding a touch input.

[0188] Referring to FIG. 12B, while displaying a screen (11200) based on a screen (1200) provided by a user terminal (1120), the user terminal (1110) can receive an input from a user (U1) related to the screen (11200). In response to the input, the user terminal (1110) can transmit a signal representing the input to the user terminal (1120). The user terminal (1120) that has received the signal can communicate with the second server (1170) and use the input corresponding to the signal to at least partially change the state of the virtual space (1100) and / or the PC (1210). The user (U1) can view the screen (1200) representing the at least partially changed state of the virtual space (1100) and / or the PC (1210) through the user terminal (1110).

[0189] As described above, an embodiment has been described in which the second server (1170) and the user terminal (1120) for providing the game service of FIG. 12B directly communicate, and the user terminal (1110) indirectly communicates with the second server (1170) using the user terminal (1120), but the embodiment is not limited thereto. For example, the user terminal (1110) that receives an input from the user (U1) related to the screen (11200) can transmit a signal including information related to the input to the second server (1170) via the communication link (L7). The signal can be transmitted directly to the second server (1170) independently of the communication links (L4, L6) established by the user terminal (1120). For example, in order to reduce the delay in the input of a user (U1) or to improve the responsiveness of a game service provided by a second server (1170), a user terminal (1110) may transmit a signal via a communication link (L7). The second server (1170) that receives the signal may transmit a signal (or information) indicating the state of a virtual space (1100) changed based on the signal to the user terminal (1120) via a communication link (L4). The user terminal (1120) that receives the signal may perform rendering on a screen (1200) to be provided to the user terminal (1110) via a communication link (L6). After a signal related to the rendered screen (1200) is transmitted to the user terminal (1110) via the communication link (L6), the user terminal (1110) can display a screen (11200) based on the signal (e.g., a screen in which a visual object (1240), an area (1230), and a group (1250) are superimposed on the screen (1200).

[0190] For example, when a communication link (L6) between user terminals (1110, 1120) is blocked, the user terminal (1110) can establish at least one of a direct communication link (L7) between a second server (1170) for providing a game service and the user terminal (1110) and / or a direct communication link (L8) between a first server (1160) for providing a game platform service and the user terminal (1110).

[0191] Although the operation of transmitting a signal representing a screen (1200) between user terminals (1110, 1120) commonly logged in by a user (U1) has been described, the embodiment is not limited thereto. For example, the user terminal (1120) may transmit a signal representing a screen (1200) to user terminals of other users logged in to the first server (1160) via the first server (1160). The function of the user terminal (1120) transmitting the signal to user terminals of other users logged in to the first server (1160) may be referred to as a broadcasting function.

[0192] Referring to FIG. 12C, a server (1260) for cloud gaming can be connected to a user terminal (1120). For example, when a request for providing a cloud-based game service is identified from a user terminal (1120), a first server (1160) can request the server (1260) to provide a cloud service based on the server (1260). The request can be transmitted to the server (1260) via a communication link (L9) between the first server (1160) and the server (1260). In response to the request, the server (1260) can establish a communication link (L10) between a second server (1170) for game services and the server (1260) and a communication link (L11) between the second server (1170) and the user terminal (1120). The request transmitted via the communication link (L9) may include information related to the user terminal (1120) that transmitted the request and / or the game service.

[0193] In one embodiment, the server (1260) may perform rendering of a screen (1200) to be displayed on a user terminal (1120). The server (1260) may transmit a signal (or bitstream) related to the screen (1200) rendered by the server (1260) to the user terminal (1120) via a communication link (L11) between the user terminal (1120) and the server (1260). The user terminal (1120) that receives the signal may display the screen (1200) represented by the signal on a display.

[0194] In the exemplary state of FIG. 12c, a user terminal (1120) displaying a screen (1200) may receive a user input related to the screen (1200). In response to the user input received from the user (U1), the user terminal (1120) may transmit a signal indicating the user input to a server (1260) via a communication link (L11). The server (1260) receiving the signal may execute a function related to the user input. The server (1260) executing the function may include an operation of at least partially changing the state of a virtual space (1100) provided by the first server (1160), for example, by communicating with the first server (1160) via a communication link (L10). For example, the server (1260) that executes the above function may include an operation of re-rendering the screen (1200) to be transmitted to the user terminal (1120) based on the state of the partially changed virtual space (1100). For example, the server (1260) that executes the above function may further transmit a signal related to the re-rendered screen (1200) through the communication link (L11).

[0195] As described above, by using the game launcher, the user terminal (1110) can display a screen (1200) of a game application running on another user terminal (in one embodiment of FIG. 12B, the user terminal (1120)) and respond to the user's (U1) interaction related to the screen (1200). The user terminal (1110) can indirectly perform graphic rendering (e.g., visualization of a three-dimensional graphical object) by using the resources of the user terminal (1120). Even if the user terminal (1110) does not have the capacity required to install the game application (e.g., available capacity of flash storage) or the user terminal (1110) does not have the resources required to run the game application (e.g., specifications of a GPU and / or CPU), the user terminal (1110) running the game launcher can provide a user experience related to the game application.

[0196] As described above, the electronic device may include a memory for storing instructions and including one or more storage media. The electronic device may include communication circuitry. The electronic device may include a display. The electronic device may include at least one processor including processing circuitry. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to display, on the display, a screen comprising a plurality of executable objects provided from a software application for a game, the screen comprising first executable objects for controlling the game and second executable objects for controlling a player character within the game. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to stream, using the communication circuitry, the screen to an external electronic device for displaying the screen on a display of the external electronic device. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to receive a first input distinct from an input designated to execute each of the plurality of executable objects while the screen is streamed to the external electronic device.The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to, in response to the first input, provide a first mode that deactivates the preset executable objects from among the plurality of executable objects and other executable objects until a function corresponding to each of the preset executable objects from among the plurality of executable objects is selected in response to a second input. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to receive the second input while the first mode is provided. The instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to, in response to the second input, execute the function selected in response to the second input from among the functions corresponding to each of the preset executable objects from among the plurality of executable objects, and to change the mode for the game from the first mode to a second mode that activates the plurality of executable objects.

[0197] According to one embodiment, the electronic device further comprises at least one sensor configured to obtain data on movement of the electronic device, wherein the first input may include a predetermined movement of the electronic device identified through the at least one sensor.

[0198] In one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to, while the first mode is provided, re-receive the first input before the second input is received, and, in response to the re-received first input, change the mode for the game from the first mode to the second mode.

[0199] In one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to identify whether the second input is received during a reference time since the first input was received while the first mode is provided, and based on the second input not being received during the reference time, change the mode for the game from the first mode to the second mode.

[0200] According to one embodiment, a housing assembly is provided, including the memory, the communication circuit, the display, and the at least one processor, the housing assembly including a front side at least partially defined by the display and a rear side opposite the front side, wherein the first input may include a tap input of tapping the rear side of the housing assembly two or more times.

[0201] In one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to, while the first mode is provided, re-receive the first input before the second input is received, and, in response to the re-received first input, change the mode for the game from the first mode to the second mode.

[0202] In one embodiment, the instructions, when individually or collectively executed by the at least one processor, may cause the electronic device to identify whether the second input is received during a reference time since the first input was received while the first mode is provided, and based on the second input not being received during the reference time, change the mode for the game from the first mode to the second mode.

[0203] According to one embodiment, the functions include functions of a first group and functions of a second group, and the screen streamed to the external electronic device is a first screen, and the instructions, when individually or collectively executed by the at least one processor, display a second screen on the display, the second screen including a first visual affordance corresponding to the first group and a second visual affordance corresponding to the second group, and being distinct from the first screen, based on providing the first mode, and receiving a third input for the first visual affordance while the second screen is displayed, and in response to the third input, stopping displaying the second screen, displaying a third screen on the display, the third screen including visual objects each representing functions included in the first group, and receiving a second input for selecting a visual object corresponding to the function among the visual objects while the third screen is displayed, and in response to the second input, executing the function, and changing the mode for the game from the first mode to the second mode. This may cause the electronic device to change.

[0204] According to one embodiment, the first visual affordance may indicate a first direction, and the second visual affordance may indicate a second direction.

[0205] According to one embodiment, the third input may include an input in which a contact point on the display is moved in the first direction among the first direction and the second direction and then released.

[0206] In one embodiment, the second input may include an input for scrolling the visual objects to select the visual object among the visual objects.

[0207] In one embodiment, the preset executable objects may include a map of the environment within the game, the visual objects may include an indicator overlaid on the map, the indicator overlaid on the map and indicating a geographic area within the game for movement of the player character, and the second input may include an input for selecting the indicator overlaid on the map.

[0208] A non-transitory computer-readable storage medium as described above may store one or more programs. The one or more programs may include instructions that, when executed by an electronic device having a display and communication circuitry, cause the electronic device to display, on the display, a screen comprising a plurality of executable objects provided from a software application for a game, the screen comprising first executable objects for controlling the game and second executable objects for controlling a player character within the game. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to stream, using the communication circuitry, the screen to an external electronic device for displaying the screen on a display of the external electronic device. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to receive a first input distinct from an input designated for executing each of the plurality of executable objects while the screen is being streamed to the external electronic device. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to, in response to the first input, provide a first mode that deactivates the preset executable objects and other executable objects from among the plurality of executable objects until one function corresponding to each of the preset executable objects from among the plurality of executable objects is selected in response to a second input. The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to receive the second input while the first mode is provided.The one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to, in response to the second input, execute a function selected from among the functions corresponding to the preset executable objects among the plurality of executable objects, and to change the mode for the game from the first mode to a second mode that activates the plurality of executable objects.

[0209] According to one embodiment, the electronic device further comprises at least one sensor configured to obtain data about movement, and the first input may comprise a predetermined movement of the electronic device identified via the at least one sensor of the electronic device.

[0210] According to one embodiment, the one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to, while the first mode is provided, re-receive the first input before the second input is received, and, in response to the re-received first input, change the mode for the game from the first mode to the second mode.

[0211] According to one embodiment, the one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to identify whether the second input is received during a reference time since the first input was received while the first mode is provided, and based on the second input not being received during the reference time, change the mode for the game from the first mode to the second mode.

[0212] According to one embodiment, the electronic device includes a housing assembly including the memory, the communication circuit, the display, and the at least one processor, and including a front side at least partially defined by the display and a rear side opposite the front side, wherein the first input may include a tap input of tapping two or more times on a rear side of the housing assembly of the electronic device that defines an exterior appearance of the electronic device.

[0213] According to one embodiment, the one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to, while the first mode is provided, re-receive the first input before the second input is received, and, in response to the re-received first input, change the mode for the game from the first mode to the second mode.

[0214] According to one embodiment, the one or more programs may include instructions that, when executed by the electronic device, cause the electronic device to identify whether the second input is received during a reference time since the first input was received while the first mode is provided, and based on the second input not being received during the reference time, change the mode for the game from the first mode to the second mode.

[0215] According to one embodiment, the functions include functions of a first group and functions of a second group, and the screen streamed to the external electronic device is a first screen, and the one or more programs, when executed by the electronic device, display a second screen on the display, the second screen including a first visual affordance corresponding to the first group and a second visual affordance corresponding to the second group, and being distinct from the first screen, based on providing the first mode, and receiving a third input for the first visual affordance while the second screen is displayed, and in response to the third input, stopping displaying the second screen, displaying a third screen on the display, the third screen including visual objects each representing functions included in the first group, and receiving a second input for selecting a visual object corresponding to the function among the visual objects while the third screen is displayed, and in response to the second input, executing the function, and changing the mode for the game from the first mode to the second mode, It may contain instructions that cause it.

[0216] According to one embodiment, the first visual affordance may indicate a first direction, and the second visual affordance may indicate a second direction.

[0217] According to one embodiment, the third input may include an input in which a contact point on the display is moved in the first direction among the first direction and the second direction and then released.

[0218] In one embodiment, the second input may include an input for scrolling the visual objects to select the visual object among the visual objects.

[0219] In one embodiment, the preset executable objects may include a map of the environment within the game, the visual objects may include an indicator overlaid on the map, the indicator overlaid on the map and indicating a geographic area within the game for movement of the player character, and the second input may include an input for selecting the indicator overlaid on the map.

[0220] The devices described above may be implemented as hardware components, software components, and / or a combination of hardware components and software components. For example, the devices and components described in the embodiments may be implemented using one or more general-purpose computers or special-purpose computers, such as a processor, a controller, an arithmetic logic unit (ALU), a digital signal processor, a microcomputer, a field programmable gate array (FPGA), a programmable logic unit (PLU), a microprocessor, or any other device capable of executing instructions and responding to them. The processing device may execute an operating system (OS) and one or more software applications running on the operating system. The processing device may also access, store, manipulate, process, and generate data in response to the execution of the software. For ease of understanding, the processing device is sometimes described as being used alone; however, one of ordinary skill in the art will recognize that the processing device may include multiple processing elements and / or multiple types of processing elements. For example, a processing unit may include multiple processors, or a processor and a controller. Other processing configurations, such as parallel processors, are also possible.

[0221] Software may include a computer program, code, instructions, or a combination of one or more of these, which may configure a processing device to perform a desired operation or may independently or collectively command the processing device. The software and / or data may be embodied in any type of machine, component, physical device, computer storage medium, or device for interpretation by the processing device or for providing instructions or data to the processing device. The software may also be distributed over networked computer systems and stored or executed in a distributed manner. The software and data may be stored on one or more computer-readable recording media.

[0222] The method according to the embodiment may be implemented in the form of program commands that can be executed through various computer means and recorded on a computer-readable medium. In this case, the medium may be one that continuously stores a computer-executable program or one that temporarily stores it for execution or download. In addition, the medium may be various recording or storage means in the form of a single or multiple hardware combinations, and is not limited to a medium directly connected to a computer system, but may also be distributed over a network. Examples of the medium may include magnetic media such as hard disks, floppy disks, and magnetic tapes, optical recording media such as CD-ROMs and DVDs, magneto-optical media such as floptical disks, and those configured to store program commands, including ROM, RAM, and flash memory. In addition, examples of other media may include recording or storage media managed by app stores that distribute applications, sites that supply or distribute various software, servers, etc.

[0223] Although the embodiments described above have been described by way of limited examples and drawings, those skilled in the art will appreciate that various modifications and variations can be made based on the above teachings. For example, appropriate results can still be achieved even if the described techniques are performed in a different order than described, and / or components of the described systems, structures, devices, circuits, etc. are combined or combined in a different manner than described, or are replaced or substituted with other components or equivalents.

[0224] Therefore, other implementations, other embodiments, and equivalents of the claims are also within the scope of the claims described below. According to one embodiment, the method according to the various embodiments disclosed in the present document may be provided as included in a computer program product. The computer program product may be traded as a commodity between a seller and a buyer. The computer program product may be distributed in the form of a machine-readable storage medium (e.g., compact disc read only memory (CD-ROM)), or may be distributed online (e.g., downloaded or uploaded) via an application store (e.g., Play Store™) or directly between two user devices (e.g., smart phones). In the case of online distribution, at least a portion of the computer program product may be at least temporarily stored or temporarily generated in a machine-readable storage medium, such as the memory of a manufacturer's server, an application store's server, or a relay server.

[0225] According to various embodiments, each component (e.g., a module or a program) of the above-described components may include one or more entities, and some of the entities may be separated and placed in other components. According to various embodiments, one or more components or operations of the aforementioned components may be omitted, or one or more other components or operations may be added. Alternatively or additionally, a plurality of components (e.g., a module or a program) may be integrated into a single component. In such a case, the integrated component may perform one or more functions of each of the plurality of components identically or similarly to those performed by the corresponding component among the plurality of components prior to the integration. According to various embodiments, the operations performed by a module, program, or other component may be executed sequentially, in parallel, iteratively, or heuristically, or one or more of the operations may be executed in a different order, omitted, or one or more other operations may be added.

Claims

1. In electronic devices, A memory that stores instructions and includes one or more storage media; communication circuit; display; and At least one processor comprising processing circuitry, The above instructions, when individually or collectively executed by the at least one processor, A screen is displayed on the display, the screen comprising a plurality of executable objects provided from a software application for a game, the first executable objects for controlling the game and the second executable objects for controlling a player character within the game, Streaming the screen to an external electronic device using the communication circuit to display the screen on the display of the external electronic device, While the screen is being streamed to the external electronic device, a first input is received that is distinct from the input designated to execute each of the plurality of executable objects, In response to the first input, a first mode is provided for disabling executable objects other than the preset executable objects among the plurality of executable objects until one function corresponding to each preset executable object among the plurality of executable objects is selected according to a second input, While the first mode is provided, the second input is received, and In response to the second input, execute the function selected from among the functions corresponding to the preset executable objects among the plurality of executable objects according to the second input, and change the mode for the game from the first mode to a second mode that activates the plurality of executable objects. causing the above electronic device, Electronic devices.

2. In claim 1, further comprising at least one sensor configured to obtain data on movement of the electronic device; The first input above is, comprising a predetermined movement of said electronic device identified through said at least one sensor; Electronic devices.

3. In claim 2, the instructions, when individually or collectively executed by the at least one processor, While the first mode is provided, the first input is received again before the second input is received, and In response to the first input received again, change the mode for the game from the first mode to the second mode, causing the above electronic device, Electronic devices.

4. In claim 2, the instructions, when individually or collectively executed by the at least one processor, While the first mode is provided, identifying whether the second input is received during a reference time since the first input was received, and Based on the second input not received during the above reference time, change the mode for the game from the first mode to the second mode. causing the above electronic device, Electronic devices.

5. In claim 1, A housing assembly comprising the memory, the communication circuit, the display, and the at least one processor, the housing assembly including a front side at least partially defined by the display and a rear side opposite the front side, The first input above is, Including a tap input for tapping the rear side of the housing assembly two or more times, Electronic devices.

6. In claim 5, the instructions, when individually or collectively executed by the at least one processor, While the first mode is provided, the first input is received again before the second input is received, and In response to the first input received again, change the mode for the game from the first mode to the second mode, causing the above electronic device, Electronic devices.

7. In claim 6, the instructions, when individually or collectively executed by the at least one processor, While the first mode is provided, identifying whether the second input is received during a reference time since the first input was received, and Based on the second input not received during the above reference time, change the mode for the game from the first mode to the second mode. causing the above electronic device, Electronic devices.

8. In claim 1, the functions are: Contains functions of the first group and functions of the second group, The above screen being streamed to the above external electronic device, This is the first screen, The above instructions, when individually or collectively executed by the at least one processor, Based on providing the first mode, a second screen is displayed on the display, the second screen including a first visual affordance corresponding to the first group and a second visual affordance corresponding to the second group, and is distinct from the first screen, While the second screen is displayed, a third input for the first visual affordance is received, In response to the third input, the display of the second screen is stopped and a third screen including visual objects each representing a function included in the first group is displayed on the display. While the third screen is displayed, the second input is received for selecting a visual object corresponding to the function among the visual objects, In response to the second input, execute the function and change the mode for the game from the first mode to the second mode. causing the above electronic device, Electronic devices.

9. In claim 8, the first visual affordance is: Indicates the first direction, The second visual affordance is, Indicating the second direction, Electronic devices.

10. In claim 9, the third input is: An input including a contact point on the display being moved in the first direction among the first direction and the second direction and then released, Electronic devices.

11. In claim 8, the second input is: Including an input for scrolling the visual objects to select the visual object among the visual objects, Electronic devices.

12. In claim 8, the preset executable objects are: Includes a map of the environment within the game, The above visual objects are, The above map having an extended size, and Including an indicator that is superimposed on the map and represents a geographical area within the game for movement of the player character, The second input above is, Including an input for selecting the indicator overlaid on the above map, Electronic devices.

13. In a non-transitory computer-readable storage medium storing one or more programs, when the one or more programs are executed by an electronic device having a display and communication circuit, A screen is displayed on the display, the screen comprising a plurality of executable objects provided from a software application for a game, the first executable objects for controlling the game and the second executable objects for controlling a player character within the game, Streaming the screen to an external electronic device using the communication circuit to display the screen on the display of the external electronic device, While the screen is being streamed to the external electronic device, a first input is received that is distinct from the input designated to execute each of the plurality of executable objects, In response to the first input, a first mode is provided for disabling executable objects other than the preset executable objects among the plurality of executable objects until one function corresponding to each preset executable object among the plurality of executable objects is selected according to a second input, While the first mode is provided, the second input is received, and In response to the second input, instructions causing the electronic device to execute the function selected from among the functions corresponding to the preset executable objects among the plurality of executable objects according to the second input, and to change the mode for the game from the first mode to a second mode that activates the plurality of executable objects. Non-transitory computer-readable storage medium.

14. In claim 13, The above electronic device, comprising at least one sensor configured to obtain data on movement of the electronic device; The first input above is, comprising a predetermined movement of the electronic device identified through at least one sensor of the electronic device; Non-transitory computer-readable storage medium.

15. In claim 14, the one or more programs, when executed by the electronic device, While the first mode is provided, the first input is received again before the second input is received, and In response to the first input received again, change the mode for the game from the first mode to the second mode, comprising instructions causing the electronic device to operate; Non-transitory computer-readable storage medium.

16. In claim 14, the one or more programs, when executed by the electronic device, While the first mode is provided, identifying whether the second input is received during a reference time since the first input was received, and Based on the second input not received during the above reference time, change the mode for the game from the first mode to the second mode. comprising instructions causing the electronic device to operate; Non-transitory computer-readable storage medium.

17. In claim 13, The above electronic device, A housing assembly comprising the memory, the communication circuit, the display, and the at least one processor, the housing assembly including a front side at least partially defined by the display and a rear side opposite the front side, The first input above is, A tap input comprising two or more taps on the rear side of the housing assembly of the electronic device, Non-transitory computer-readable storage medium.

18. In claim 17, the one or more programs, when executed by the electronic device, While the first mode is provided, the first input is received again before the second input is received, and In response to the first input received again, change the mode for the game from the first mode to the second mode, comprising instructions causing the electronic device to operate; Non-transitory computer-readable storage medium.

19. In claim 18, the one or more programs, when executed by the electronic device, While the first mode is provided, identifying whether the second input is received during a reference time since the first input was received, and Based on the second input not received during the above reference time, change the mode for the game from the first mode to the second mode. comprising instructions causing the electronic device to operate; Non-transitory computer-readable storage medium.

20. In claim 13, The above functions include functions of the first group and functions of the second group, The above screen being streamed to the above external electronic device, This is the first screen, The above one or more programs, when executed by the electronic device, Based on providing the first mode, a second screen is displayed on the display, the second screen including a first visual affordance corresponding to the first group and a second visual affordance corresponding to the second group, and is distinct from the first screen, While the second screen is displayed, a third input for the first visual affordance is received, In response to the third input, the display of the second screen is stopped and a third screen including visual objects each representing a function included in the first group is displayed on the display. While the third screen is displayed, the second input is received for selecting a visual object corresponding to the function among the visual objects, In response to the second input, execute the function and change the mode for the game from the first mode to the second mode. comprising instructions causing the electronic device to operate; Non-transitory computer-readable storage medium.

Images