Method and System for Verifying Game Content Translations Based on AI-Based Error Report Management

Abstract

The following embodiments relate to a technology for automatically verifying translation quality issues that occur during the game localization process. More specifically, they relate to an integrated quality verification system that utilizes a neural network-based vision model to detect and classify linguistic and visual display errors in translated text extracted from game screens in real time. An electronic device that communicates with a user terminal for a user according to one embodiment to provide a game translation check service comprises a memory that stores at least one instruction and a processor that executes said at least one instruction, wherein the processor receives game screen data, which is data regarding a game screen translated from a first language to a second language, extracts text data including a plurality of texts displayed in the second language from said game screen data, and analyzes said text data through a vision model that has been pre-trained based on a neural network, thereby determining whether a translation error has occurred during the process of translating from the first language to the second language, and can generate an error report based on the result of determining said translation error.

Description

Technology Field

[0001] The following embodiments relate to a technology for automatically verifying translation quality issues that occur during the game localization process. More specifically, they relate to an integrated quality verification system that utilizes a neural network-based vision model to detect and classify linguistic and visual display errors in translated text extracted from game screens in real time. Background Technology

[0002] With the rapid growth of the global game market, multilingual support has become an essential element. In particular, as games from Asian markets such as Korea, China, and Japan expand into North American and European markets, the importance of accurate and natural localization is becoming increasingly prominent. Game localization goes beyond simply translating text and requires a comprehensive adaptation process that considers the cultural context and linguistic characteristics of each region. In this process, Linguistic Quality Assurance (LQA) is recognized as an essential step for verifying in advance various quality issues that may arise when translated content is applied to game builds.

[0003] The traditional LQA process has primarily relied on human testers manually playing games to identify translation errors. Testers inspect each screen individually to identify issues such as text truncation, broken characters, missing translations, contextually inappropriate translations, and errors in the use of honorifics between characters, recording these findings in spreadsheets or dedicated reporting tools. This manual approach has several fundamental limitations. First, for large-scale games, the sheer volume of text to be verified makes it practically impossible to thoroughly review every piece of content. For instance, modern RPGs contain millions of words of dialogue and thousands of UI elements, requiring an enormous amount of time and manpower to verify everything manually.

[0004] Second, there is the issue of inconsistency caused by the subjectivity and fatigue of human testers. The same error may be judged differently by each tester, and accumulated fatigue from long working hours significantly reduces the error detection rate. In particular, the detection of errors related to subtle linguistic nuances or cultural contexts can vary greatly depending on the tester's language proficiency and cultural background. Third, it is difficult to respond to repetitive updates and patches. Modern games evolve through continuous content updates and patches, and manually re-verifying every change is inefficient and incurs high costs.

[0005] From a technical perspective, the text displayed on the game screen is not merely a simple string of characters but is implemented through a complex UI system and rendering engine. UI elements developed in the original language can cause various visual issues due to differences in text length when translated. For example, while text length typically decreases by 20–30% when translating from English to Korean, it can increase by 30–40% when translating from German. These length differences lead to text truncation or overflow issues in UI elements such as buttons, dialogue boxes, and menu boxes. Furthermore, in the case of RTL (Right-to-Left) languages ​​like Arabic or Hebrew, the orientation of the entire UI layout must be changed; this process frequently results in misalignment of UI elements or distortion of the visual hierarchy.

[0006] From a linguistic perspective, even more complex issues exist. Dialogue between in-game characters must maintain an appropriate tone and level of honorifics based on each character's personality, relationship, and situation. Particularly when translating into languages ​​with complex honorific systems, such as Korean and Japanese, consistent use of honorifics that consider the characters' age, position, and level of intimacy is essential. However, maintaining such consistency is extremely difficult when thousands of dialogue files are processed by multiple translators; consequently, unnatural phenomena occur where the same character uses different speech patterns depending on the situation.

[0007] Although some automation tools have been developed recently, they are primarily limited to simple text comparisons or basic string length checks. For example, while translation memory systems can verify consistency with previously translated text, they cannot verify how the text is displayed on the actual game screen. Furthermore, because existing automation tools do not understand context, they fail to detect translations that are grammatically correct but inappropriate for the game situation. For instance, the word "Save" should be translated as "Save" in the game menu but as "Rescue" in combat situations, yet existing tools cannot distinguish these contextual differences. Prior art literature

[0008] Publication No. 10-2025-0105150(2025.07.08) The problem to be solved

[0009] The embodiments aim to provide an integrated quality verification system capable of simultaneously detecting linguistic errors and visual display errors by overcoming the limitations of existing manual verification methods through a neural network-based vision model that automatically verifies translation quality issues occurring during the game localization process. means of solving the problem

[0010] An electronic device that communicates with a user terminal for a user according to one embodiment to provide a game translation check service comprises a memory that stores at least one instruction and a processor that executes said at least one instruction, wherein the processor receives game screen data, which is data regarding a game screen translated from a first language to a second language, extracts text data including a plurality of texts displayed in the second language from said game screen data, and analyzes said text data through a vision model that has been pre-trained based on a neural network, thereby determining whether a translation error has occurred during the process of translating from the first language to the second language, and can generate an error report based on the result of determining said translation error.

[0011] Additionally, the processor extracts a container area representing the boundary coordinates and size of UI (User Interface) elements, including buttons, dialog boxes, and menu boxes containing text, from the game screen data, extracts a text display area representing the coordinates and size of the pixel area actually occupied by the extracted text data, and compares and determines whether the text display area extends beyond the boundary of the container area; if it is determined that the text display area extends beyond the boundary of the container area, it calculates the ratio of the text extending beyond the boundary of the container area relative to the total text using the vision model, and if the calculated ratio exceeds a predefined threshold, it further determines whether the core meaning of the original text has been lost by comparing it with the original text of the first language, and records it as a text truncation error in the error report.

[0012] In addition, if the second language is a right-to-left (RTL) language, the processor can determine the text progression direction by extracting the start and end point coordinates of each of the plurality of texts from the game screen data, determine the on-screen placement order and alignment reference point of the UI elements, detect as a layout error cases where the text progression direction proceeds from left to right or the on-screen placement order of the determined UI elements is arranged opposite to the RTL language rules, quantify and evaluate the degree of impact of the detected layout error on the user's readability and game progression through the vision model, and automatically generate specific correction guides for the correct text direction and UI placement in the error report.

[0013] Additionally, the processor can query the original text of the first language and the corresponding standard translation text of the second language from a pre-established translation memory database, compare the text data extracted from the game screen data with the standard translation text on a string-by-string basis to identify the discrepancy where a discrepancy exists, and when the discrepancy is identified, use the vision model to comprehensively analyze the in-game situation, surrounding UI elements, and character dialogue context where the text corresponding to the discrepancy is displayed, thereby determining whether the discrepancy corresponds to an intentional translation change tailored to the situation or an actual translation error, and if the discrepancy is determined to be an actual translation error, classify the translation error into one of a linguistic error which is a pure translation problem, a visual error which is a screen display problem, or a complex error which is both a linguistic error and a visual error, and record the classification result in the error report.

[0014] Additionally, if the second language is a language having an honorific system, the processor can extract name, position, and age information of characters identified as speaker and listener in a dialogue text containing a conversation between characters among the plurality of texts of the game screen data, analyze the hierarchical relationship, intimacy, and formality of the conversation situation between characters based on the extracted name, position, and age information of the characters to determine an appropriate honorific level, analyze the endings, titles, and honorific expressions of the dialogue text to identify the current honorific level, compare the determined appropriate honorific level with the current honorific level, and if inappropriate use of honorifics is detected in the dialogue text as a result of the comparison, re-verify the appropriate honorific level by additionally analyzing visual cues including the character's clothing, facial expression, and posture through the vision model, and if it is finally confirmed that inappropriate use of honorifics has been confirmed, generate an example sentence that converts the dialogue text to the correct honorific level.

[0015] Additionally, when the game screen data is provided in multiple language versions, the processor captures the screen data of the first language version and the screen data of the second language version at the same point in time of game progression, respectively, and calculates the difference in size of the text display area corresponding to the same UI element in pixels between the captured screen data of both language versions; if the calculated size difference exceeds a preset allowable range, it determines whether the text of the second language occupies more space or less space than the text of the first language; if it is determined that the text of the second language occupies more space, it calculates the maximum expandable area by measuring the margin space around the text and the gap with adjacent UI elements using the vision model; if the calculated maximum area is insufficient to accommodate the text of the second language, it determines the optimal display method by sequentially applying modification measures such as adjusting the line break position of the text or reducing the font size, and records the determined optimal display method as a specific modification guideline in the error report.

[0016] In addition, if there are multiple translation candidates for standard translation text of a second language corresponding to the original text of the first language in the translation memory database, the processor checks the usage frequency and last modification date of each translation candidate, selects the translation candidate with the highest confirmed usage frequency as the priority standard translation, and compares it with the text extracted from the game screen data; if a discrepancy occurs as a result of the comparison and the extracted text matches another translation candidate in the translation memory database, analyzes the character, background, and item information displayed on the screen through the vision model to identify the in-game situation in which the translation candidate was selected, and if it is determined that the analyzed in-game situation corresponds to a specific event scene or a special dialogue situation, it further searches for translation patterns used in similar situations in the translation memory database to verify consistency, and if consistency is not maintained as a result of the verification, it proposes a unified translation term to be used in the same situation and marks all related text locations as targets for batch correction in the error report.

[0017] Additionally, the processor tracks the sequence of each conversation in chronological order in the conversation text containing the conversation between the characters, and stores the level of honorifics between characters set in the first conversation according to the tracked conversation sequence as a reference value. However, if a level of honorifics different from the stored reference value is detected in subsequent conversations, the processor analyzes whether there is a change in the character's clothing, a change in title, or a transition to a story chapter through the vision model to check for the possibility of a change in the character relationship according to the progression of the game story. If no element indicating a change in the character relationship is found as a result of the analysis, it is determined to be inconsistent use of honorifics and suggests modifying it to a level of honorifics that matches the reference value. Conversely, if an element indicating a change in the character relationship is found, a new level of honorifics suitable for the changed relationship is reset, and the processor can continue to track and verify whether the new level of honorifics is consistently maintained in subsequent conversations.

[0018] Additionally, an electronic device according to one embodiment may be combined with hardware and controlled by a computer program stored on a medium to execute the method of any one of the methods described above. Effects of the invention

[0019] The embodiments can make a significant contribution to strengthening the competitiveness of the global game market by innovatively transforming the quality management paradigm of the entire game localization industry.

[0020] More specifically, the embodiments demonstrate that by introducing a neural network-based vision model, the fundamental limitations of existing manual verification methods can be overcome, thereby dramatically improving the accuracy and efficiency of quality verification. In the existing LQA process, a skilled tester could review an average of 2,000 to 3,000 text strings per day; however, the automated system of this embodiment can process over 50,000 text strings in the same amount of time, resulting in a productivity improvement of more than 20 times. This revolutionary improvement in processing speed is not merely a quantitative increase but is accompanied by qualitative enhancements that enable the detection of even minute errors that human testers are prone to missing. For example, it can accurately detect text truncation at the one-pixel level or translation errors in flash text displayed for only 0.1 seconds, providing a level of precision that surpasses the limits of human vision.

[0021] Furthermore, the embodiments can perform intelligent error detection that goes beyond simple text matching by utilizing the context-aware capabilities of the vision model. In games, it is common for the same word to need to be translated differently depending on the situation; for example, the word "Critical" may be translated as "critical hit" in combat situations, "serious" in system messages, and "decisive" in item descriptions. This system can determine whether a translation is appropriate for each situation by comprehensively analyzing visual elements on the game screen and surrounding text, thereby effectively identifying contextually inappropriate translations. Moreover, it can grasp the tone and atmosphere of dialogue by utilizing visual cues such as character facial expressions, background environments, and UI design, and verify whether an appropriate translation style has been applied.

[0022] The embodiments can also realize true global quality management by providing customized verification that takes into account the unique characteristics of various languages. For RTL languages, not only the text direction but also the mirroring of the entire UI layout is verified at the pixel level to ensure it is correctly applied, and the directionality of icons or progress bars is checked in detail. For the complex honorific systems of Asian languages, a relationship diagram between characters is constructed, and it tracks whether consistent use of honorifics is maintained throughout the entire game story. For example, in a 100-hour RPG game, it automatically monitors whether the honorifics used by a specific NPC toward the protagonist change appropriately as the story progresses, and if an unnatural change is detected, it flags it and marks it for review.

[0023] The introduction of these embodiments can create positive ripple effects throughout the entire game development process. By enabling real-time monitoring of translation quality from the early stages of development, it is possible to prevent emergency patches or launch delays caused by critical translation errors discovered just before release. This increases the predictability of development schedules and significantly reduces project management risks. In fact, for large-scale AAA games, the opportunity cost of launch delays can amount to millions of dollars per day, and this system can prevent such risks in advance. Furthermore, for live service games where continuous content updates are essential, the translation quality of new content added weekly can be verified immediately, ensuring that players are consistently provided with a high-quality experience.

[0024] From an economic perspective, these embodiments can fundamentally improve the localization cost structure. While traditional LQA processes had a high cost structure accounting for 30-40% of the total localization budget, the introduction of this system can reduce this to 10-15%. The saved costs can be reinvested in localizing into more languages ​​or strengthening cultural adaptation elements, thereby improving the game's global accessibility and market penetration. In particular, for small and medium-sized developers, localization, which was previously limited to major languages ​​due to budget constraints, can be expanded to a wider range of regional languages, thereby securing opportunities to enter niche markets.

[0025] The embodiments also provide the effect of strengthening the knowledge base of the localization industry through the systematic accumulation and analysis of translation quality data. By analyzing error patterns and frequencies detected by the system, recurring issues in specific language pairs or game genres can be identified, enabling the continuous improvement of translation guidelines and style guides. For example, frequently occurring error types during Korean-to-English translation can be databased and utilized as training material for translators or to enhance the accuracy of translation memory systems. In the long term, this data can serve as foundational material for developing better machine translation models, creating a virtuous cycle that improves the technological level of the entire industry.

[0026] The real-time feedback mechanism of the embodiments can significantly improve the efficiency of collaboration between translators and developers. Translators can immediately see how the text they have worked on appears on the actual game screen, allowing them to quickly make adjustments to text length or modify expressions. This enables the immediate resolution of issues that were previously discovered only weeks after translation was completed, thereby reducing the overall localization cycle time by more than 50%. Additionally, developers can identify the impact of UI design changes on the multilingual version in real time, allowing them to make localization-friendly design decisions.

[0027] In terms of player experience, the embodiments provide the effect of significantly improving the immersion and completeness of the game. Visual errors, such as text truncation or broken characters, can hinder player immersion and raise doubts about the professionalism of the game, but this system can fundamentally prevent such problems. Particularly in story-driven games, the consistency and naturalness of translation directly affect the emotional immersion of players; by maintaining consistency in the speech patterns of each character and applying an appropriate tone for the situation, a storytelling experience equivalent to the original work can be provided. Analysis of actual user reviews showed that negative evaluations due to translation quality issues accounted for 15-20% of all negative reviews, but it is expected that this can be reduced to 5% or less with the application of this system.

[0028] The embodiments can also make a significant contribution to improving accessibility. By automating screen reader compatibility verification for the visually impaired, font readability checks for dyslexic users, and color contrast verification for colorblind users, a more inclusive gaming experience can be provided. In particular, in multilingual environments, different accessibility requirements exist for each language; for instance, Chinese requires larger font sizes for the readability of complex characters, while Arabic requires special rendering processing for the correct display of connected characters. This system can automatically verify these language-specific requirements to ensure an equal gaming experience for all players.

[0029] The continuous learning mechanism of the embodiments provides a self-evolving capability that improves system performance over time. By learning from false positives and false negatives through feedback from human reviewers, verification accuracy can be continuously improved, and adaptability to new game genres or UI styles can be enhanced. For example, it can rapidly learn new design trends, such as the recently popular cyberpunk style UI or retro pixel art text display methods, to perform accurate verification. This adaptability is highly suitable for the characteristics of the rapidly changing game industry and guarantees the long-term utility value of the system.

[0030] The embodiments can also be utilized for verifying regulatory compliance and cultural appropriateness, thereby reducing risks in the global distribution process. It can automate content verification considering age rating standards, cultural sensitivities, and legal restrictions specific to each country, and supports the appropriate modification of expressions or images taboo in certain regions by detecting them in advance during the localization process. For example, the Chinese market has regulations regarding images such as skulls or ghosts, while the Middle East has restrictions on content related to alcohol or gambling; this system automatically flags these elements to facilitate region-specific modifications.

[0031] Finally, the embodiments suggest the potential for expansion beyond the game industry into various digital content fields. It is applicable to all UI-based digital products, such as mobile apps, websites, educational software, and enterprise applications, and can serve as an essential quality control tool, particularly for platform companies providing global services. Furthermore, it is expected to play a key role in next-generation interface environments, such as verifying text display in the 3D space of augmented reality (AR) or virtual reality (VR) content and verifying multilingual responses in voice recognition-based interfaces. This scalability further enhances the technical value of the invention and can contribute to accelerating the globalization of the digital content industry as a whole. Brief explanation of the drawing

[0032] FIG. 1 is a diagram illustrating the relationship between a user terminal and an electronic device according to one embodiment. FIG. 2 is a diagram illustrating the overall architecture of a game translation inspection system according to one embodiment. FIG. 3 is a block diagram of an electronic device according to one embodiment. FIG. 4 is a flowchart illustrating the operation of an electronic device according to one embodiment. FIG. 5 is a diagram illustrating a text truncation error detection process according to one embodiment. FIG. 6 is a diagram illustrating an RTL language layout verification process according to one embodiment. FIG. 7 is a diagram illustrating an error classification process using a translation memory database according to one embodiment. FIG. 8 is a diagram illustrating a process for verifying the level of honorifics according to one embodiment. FIG. 9 is a drawing showing an example of an error report generation screen according to one embodiment. Specific details for implementing the invention

[0033] Hereinafter, embodiments are described in detail with reference to the attached drawings. However, various modifications may be made to the embodiments, and thus the scope of the patent application is not limited or restricted by these embodiments. It should be understood that all modifications, equivalents, and substitutions to the embodiments are included within the scope of the rights.

[0034] Specific structural or functional descriptions of the embodiments are disclosed for illustrative purposes only and may be modified and implemented in various forms. Accordingly, the embodiments are not limited to the specific disclosed forms, and the scope of this specification includes modifications, equivalents, or substitutions that fall within the technical concept.

[0035] Terms such as "first" or "second" may be used to describe various components, but these terms should be interpreted solely for the purpose of distinguishing one component from another. For example, the first component may be named the second component, and similarly, the second component may be named the first component.

[0036] Furthermore, terms defined in commonly used dictionaries are not interpreted ideally or excessively unless explicitly and specifically defined otherwise. In certain cases, terms have been selected at the applicant's discretion, and in such cases, their meanings will be described in detail in the relevant explanatory sections. Accordingly, terms used in this disclosure should be defined not merely by their names, but based on their meanings and the content throughout this disclosure.

[0037] When it is stated that a component is "connected" to another component, it should be understood that it may be directly connected to or coupled with that other component, or that there may be other components in between.

[0038] The terms used in the embodiments are for illustrative purposes only and should not be interpreted as intended to be limiting. Singular expressions include plural expressions unless the context clearly indicates otherwise. In this specification, terms such as "comprising" or "having" are intended to indicate the existence of the features, numbers, steps, actions, components, parts, or combinations thereof described in the specification, and should be understood as not precluding the existence or addition of one or more other features, numbers, steps, actions, components, parts, or combinations thereof.

[0039] Throughout this specification, when a part is described as “comprising” a certain component, this means that, unless specifically stated otherwise, it does not exclude other components but may include additional components. Furthermore, the singular form used in this specification includes the plural form unless specifically stated otherwise in the text. Additionally, the expression “at least one of b and c” described throughout this specification may encompass ‘a alone,’ ‘b alone,’ ‘c alone,’ ‘a and b,’ ‘a and c,’ ‘b and c,’ or ‘a, b, and c all.’

[0040] Unless otherwise defined, all terms used herein, including technical or scientific terms, have the same meaning as generally understood by those skilled in the art to which the embodiments pertain. Terms such as those defined in commonly used dictionaries should be interpreted as having a meaning consistent with their meaning in the context of the relevant technology, and should not be interpreted in an ideal or overly formal sense unless explicitly defined in this application.

[0041] Additionally, terms such as “…part,” “…module,” etc., as described in this specification refer to a unit that processes at least one function or operation, which may be implemented in hardware or software, or a combination of hardware and software. Furthermore, embodiments of the present disclosure may be represented by functional block configurations and various processing steps. These functional blocks may be implemented by various numbers of hardware and / or software configurations that execute specific functions. For example, embodiments of the present disclosure may employ integrated circuit configurations such as memory, processing, logic, look-up tables, etc., which can execute various functions under the control of one or more microprocessors or other control devices.

[0042] Each block of the process flow diagrams attached to this specification and combinations of the flow diagrams may be executed by computer program instructions. Since these computer program instructions may be loaded into the processor of a general-purpose computer, a computer for special purposes, or other programmable data processing equipment, the instructions executed through the processor of the computer or other programmable data processing equipment create means for performing the functions described in the flow diagram block(s).

[0043] These computer program instructions may be stored in computer-available or computer-readable memory that can be directed toward a computer or other programmable data processing equipment to implement a function in a specific way, and the instructions stored in said computer-available or computer-readable memory may also produce a manufactured item containing instruction means that performs the function described in the flowchart block(s).

[0044] Since computer program instructions can be loaded onto a computer or other programmable data processing equipment, instructions that perform a series of operation steps on the computer or other programmable data processing equipment to create a process executed by the computer can also provide steps for executing the functions described in the flowchart block(s).

[0045] Additionally, each block may represent a module, segment, or part of code containing one or more executable instructions for executing a specified logical function(s). Furthermore, in some alternative execution examples, the functions mentioned in the blocks may occur out of order. For instance, two blocks described in succession may actually be executed substantially simultaneously, or the blocks may be executed in reverse order according to their corresponding functions.

[0046] In addition, when describing with reference to the attached drawings, identical components are assigned the same reference numeral regardless of drawing symbols, and redundant descriptions thereof are omitted. In describing the embodiments, if it is determined that a detailed description of related prior art could unnecessarily obscure the essence of the embodiments, such detailed description is omitted.

[0047] FIG. 1 is a diagram illustrating the relationship between a user terminal and an electronic device according to one embodiment.

[0048] Referring to FIG. 1, a game translation check system according to one embodiment of the present disclosure may include a user terminal (100) and an electronic device (200). In this case, the game translation check system according to one embodiment of the present disclosure may be a system that provides a game translation check service using communication between the user terminal (100) and the electronic device (200).

[0049] The user terminal (100) is a terminal for a user who performs game localization quality verification work. At this time, the user may include a game developer, a localization project manager, an LQA tester, a translator, etc., but the embodiments of the present invention are not limited thereto.

[0050] A game translation check program provided by an electronic device (200) may be installed on such a user terminal (100). In other words, the user terminal (100) can perform data communication with the electronic device (200) through the game translation check program installed on the user terminal (100). At this time, the game translation check program may be in the form of a Web or an App, but the embodiments of the present invention are not limited thereto.

[0051] As an example, a user terminal (100) can transmit game screen data to an electronic device (200) and receive an error report including the results of an analysis of translation errors regarding the game screen data. Additionally, the user terminal (100) can provide the electronic device (200) with feedback regarding the verification results or corrections for the error report.

[0052] These user terminals (100) may be smartphones, tablet personal computers, laptop personal computers, desktop PCs, wearable devices (e.g., smart watches, smart TVs, set-top boxes, consoles), terminals dedicated to virtual reality (VR) and augmented reality (AR) (e.g., head-mounted devices, smart home devices), special industrial terminals, vehicle terminals, etc., but are not limited thereto.

[0053] The electronic device (200) is a device that provides a game translation inspection service. For example, the electronic device (200) may include a device that performs data communication with a user terminal (100) to receive game screen data, automatically detects translation errors using a neural network-based vision model, and generates a detailed report on the detected errors and provides it to the user.

[0054] An electronic device (200) according to one embodiment of the present disclosure may be a server, a terminal, or a device that performs various other operations and functions.

[0055] For example, if the electronic device (200) is a server, the electronic device (200) may be an FTP server (File Transfer Protocol Server), a web server, a database server, or a cloud server, but is not limited thereto. The server may perform one or more functions and operations, and may be implemented as a single device or distributed across multiple devices so that each function and operation is implemented.

[0056] As another example, when the electronic device (200) is a terminal, the electronic device (200) may be a smartphone, tablet personal computer, laptop personal computer, desktop PC, wearable device (e.g., smart watch, smart TV, set-top box, console), a terminal dedicated to virtual reality (VR) and augmented reality (AR) (e.g., head-mounted device (HMD), smart home device), a special industrial terminal, a vehicle terminal, etc., but is not limited thereto. The customer terminal may perform one or more functions and operations, and may be implemented as a single device or distributed across multiple devices so that each function and operation is implemented.

[0057] In addition, the electronic device (200) may be an IoT device (Internet of Things Devices), a sensor device, a drone, or a robot. In this case, the electronic device (200) may be implemented as a single device, but may also be implemented as a set or combination of two or more devices.

[0058] As an example, the electronic device (200) receives game screen data, which is data regarding a game screen translated from a first language to a second language, from a user terminal (100), extracts text data including a plurality of texts displayed in the second language from the game screen data, determines whether there is a translation error by analyzing the text data through a vision model pre-trained based on a neural network, and generates an error report based on the determination result. A detailed explanation thereof will be provided later.

[0059] Hereinafter, with reference to FIG. 2, the overall architecture of a game translation inspection system including a user terminal (100) and an electronic device (200) according to one embodiment of the present disclosure will be described in a schematic manner.

[0060] FIG. 2 is a diagram illustrating the overall architecture of a game translation inspection system according to one embodiment.

[0061] Referring to FIGS. 1 and 2, the overall architecture of a game translation verification system according to one embodiment of the present disclosure consists of a series of operations performed by an electronic device (200). The electronic device (200) performs operations sequentially or in parallel, such as capturing multilingual UI screenshots and logging UI status, OCR and text extraction, error detection and classification through an AI vision model, querying and comparing a translation memory database, supporting review by human linguists, and continuous learning and model improvement. This series of processing operations is designed as an integrated workflow that automatically detects and classifies complex translation errors occurring during the game localization process and improves verification accuracy through continuous learning.

[0062] The electronic device (200) can first capture multilingual UI screenshots and log the UI state. In this process, the electronic device (200) utilizes an automation framework such as Selenium WebDriver or Appium to automatically run the game and systematically capture each screen according to a predefined scenario. During the capture process, the electronic device (200) stores metadata such as the current game state, screen ID, language code, device information, resolution, and timestamp in JSON format so that it can be used in a subsequent analysis process. In particular, the electronic device (200) facilitates comparative analysis between languages ​​by synchronizing and capturing screens of multiple language versions at the same point in time during the game.

[0063] Next, the electronic device (200) can extract text by performing OCR on the captured screenshot. The electronic device (200) recognizes text within the image using the Tesseract OCR engine or the Google Cloud Vision API and extracts attributes such as the location information (bounding box), font size, and color of each text. In this process, the electronic device (200) applies a preprocessing algorithm to accurately recognize text on game-specific stylized fonts or complex backgrounds. The electronic device (200) structures and stores the extracted text by UI element and classifies it according to UI types such as buttons, dialog boxes, menus, and tooltips.

[0064] Next, the electronic device (200) can detect and classify errors by utilizing an AI vision model. The electronic device (200) utilizes a multimodal large-scale language model such as GPT-40 to simultaneously analyze image and text data and automatically detect various types of translation errors. Beyond simple text comparison, the electronic device (200) understands the visual context of the game screen and determines the appropriateness of the translation by comprehensively considering the character's facial expressions, background environment, UI design, etc. When an error is detected, the electronic device (200) classifies it into linguistic errors, visual errors, and hybrid errors, and evaluates the severity and correction priority of each error.

[0065] Additionally, the electronic device (200) can query a translation memory database and compare it with existing translations. The electronic device (200) queries original text, translated text, context information, translator information, approval status, etc., stored in an internal or external database, and can track the history of changes to the translation through a version control function. The electronic device (200) refers to this database to verify whether the text on the current game screen matches the approved translation, and if a discrepancy is found, flags it as a potential error.

[0066] The electronic device (200) can provide an interface to support a review by a human linguist. The electronic device (200) creates a web-based dashboard that visually displays the game screen where errors are detected and detailed error information, and supports the linguist in taking actions such as "confirm," "reject," or "suggest correction" for each error. When the electronic device (200) receives feedback from the linguist, it immediately reflects it in the system and uses it as training data for the AI ​​model, enabling the detection of errors of similar patterns more accurately.

[0067] Finally, the electronic device (200) can improve system performance through continuous learning. The electronic device (200) collects feedback from human linguists, new error patterns, game-specific terminology, etc., to optimize the AI ​​model's prompts or fine-tune the model as needed. The electronic device (200) utilizes the Retrieval-Augmented Generation (RAG) method to build a knowledge base specialized by game, genre, and language pair, and performs more accurate error detection based on this. Additionally, the electronic device (200) evaluates the effectiveness of various prompt strategies through A / B testing and automatically selects the optimal setting.

[0068] These series of operations performed by the electronic device (200) are implemented in a microservices architecture, so that each processing step can be independently scalable and thousands of game screens can be analyzed simultaneously through large-scale parallel processing. Additionally, the electronic device (200) can be flexibly operated in both on-premises and cloud environments through containerized deployment and seamlessly integrated with existing game development pipelines via RESTful APIs.

[0069] Hereinafter, an electronic device (200) according to one embodiment of the present disclosure will be described in more detail with reference to FIG. 3.

[0070] FIG. 3 is a block diagram of an electronic device according to one embodiment.

[0071] Referring to FIGS. 1 to 3, an electronic device (200) according to one embodiment of the present disclosure may include a communication interface (210), a memory (220), and a processor (230). However, the embodiments of the present disclosure are not limited thereto, and some of the components shown in FIG. 3 may be omitted, or other components not shown in FIG. 3 may be included in the electronic device (200).

[0072] The communication interface (210) may be a configuration responsible for communication with the user terminal (100) and an external system.

[0073] For example, the communication interface (210) may include at least one of a wireless communication interface, a wired communication interface, and an input / output interface. The wireless communication interface may communicate with various external devices using wireless communication technology or mobile communication technology. Such wireless communication technologies may include, for example, Bluetooth, Bluetooth Low Energy, CAN communication, Wi-Fi, Wi-Fi Direct, ultrawide band (UWB), Zigbee, infrared data association (IrDA), or near field communication (NFC), and mobile communication technologies may include 3GPP, Wi-Max, LTE, 5G, etc. The wireless communication interface may be implemented using an antenna, a communication chip, and a substrate, etc., capable of transmitting electromagnetic waves to the outside or receiving electromagnetic waves transmitted from the outside. The wired communication interface can communicate with various devices based on a wired communication network. Here, the wired communication network can be implemented using physical cables, such as, for example, a pair cable, a coaxial cable, a fiber optic cable, or an Ethernet cable. The input / output interface can be configured to be connected to another device, such as an external storage device, provided separately from the electronic device (200).For example, the input / output interface may be a Universal Serial Bus (USB) terminal, or it may be any one of the following interfaces: HDMI (High Definition Multimedia Interface), MHL (Mobile High-Definition Link), USB (Universal Serial Bus), DP (Display Port), Thunderbolt, VGA (Video Graphics Array) port, RGB port, D-SUB (D-subminiature), or DVI (Digital Visual Interface). The input / output interface may input or output at least one of audio and video signals. Depending on the implementation example, the input / output interface may include separate ports for inputting and outputting only audio signals and for inputting and outputting only video signals, or it may be implemented as a single port for inputting and outputting both audio and video signals.

[0074] The memory (220) stores various programs or data temporarily or non-temporarily and transmits the stored information to the processor upon the call of the processor (230). Additionally, the memory (220) can store various information required for the operation, processing, or control operation of the processor (230) in an electronic format.

[0075] The memory (220) may include, for example, at least one of a main memory and an auxiliary memory. The main memory may be implemented using a semiconductor storage medium such as ROM and / or RAM. The ROM may include, for example, a conventional ROM, EPROM, EEPROM and / or MASK-ROM. The RAM may include, for example, a DRAM and / or SRAM. The auxiliary memory may be implemented using at least one storage medium capable of storing data permanently or semi-permanently, such as a flash memory (220) device, an SD (Secure Digital) card, a Solid State Drive (SSD), a Hard Disc Drive (HDD), an optical recording medium such as a magnetic drum, a Compact Disc (CD), a DVD, or a laser disc, a magnetic tape, a magneto-optical disc and / or a floppy disk.

[0076] The memory (220) stores various programs or data temporarily or non-temporarily and transmits the stored information to the processor upon the call of the processor (230). In particular, the memory (220) can store game screen data, extracted text data, translation memory database, error detection algorithm, AI model parameters, error report template, etc.

[0077] The processor (230) may be implemented in various ways. For example, one or more processors (230) may include one or more of a CPU (Central Processing Unit), GPU (Graphics Processing Unit), APU (Accelerated Processing Unit), MIC (Many Integrated Core), DSP (Digital Signal Processor), NPU (Neural Processing Unit), hardware accelerator, or machine learning accelerator. One or more processors (230) may control one or any combination of other components of the electronic device (200) and may perform operations or data processing related to communication. One or more processors (230) may execute one or more programs or instructions stored in memory (220). For example, one or more processors (230) may perform a method according to one embodiment of the present disclosure by executing one or more instructions stored in memory (220).

[0078] In embodiments of the present disclosure, the processor (230) may mean a system-on-chip (SoC) in which one or more processors (230) and other electronic components are integrated, a single-core processor, a multi-core processor, or a core included in a single-core processor or a multi-core processor, wherein the core may be implemented as a CPU, GPU, APU, MIC, DSP, NPU, hardware accelerator, or machine learning accelerator, but the embodiments of the present disclosure are not limited thereto.

[0079] In the case where the method according to one embodiment of the present disclosure includes a plurality of operations, the plurality of operations may be performed by a single processor (230) or by a plurality of processors (230). For example, when a first operation, a second operation, and a third operation are performed by the method according to one embodiment, the first operation, the second operation, and the third operation may all be performed by a first processor, or the first operation and the second operation may be performed by a first processor (e.g., a general-purpose processor) and the third operation may be performed by a second processor (e.g., an artificial intelligence dedicated processor).

[0080] One or more processors (230) may be implemented as a single-core processor including one core, or as one or more multi-core processors including multiple cores (e.g., homogeneous multi-core or heterogeneous multi-core). When one or more processors (230) are implemented as multi-core processors, each of the multiple cores included in the multi-core processor may include internal processor memory (220), such as on-chip memory (220), and a common cache shared by multiple cores may be included in the multi-core processor (230). Additionally, each of the multiple cores (or some of the multiple cores) included in the multi-core processor (230) may independently read and execute program instructions for implementing a method according to one embodiment of the present disclosure, or all (or some) of the multiple cores may be linked together to read and execute program instructions for implementing a method according to one embodiment of the present disclosure.

[0081] When a method according to one embodiment of the present disclosure includes a plurality of operations, the plurality of operations may be performed by one of the plurality of cores included in a multi-core processor, or may be performed by a plurality of cores. For example, when a first operation, a second operation, and a third operation are performed by a method according to one embodiment, the first operation, the second operation, and the third operation may all be performed by a first core included in a multi-core processor, or the first operation and the second operation may be performed by a first core included in a multi-core processor and the third operation may be performed by a second core included in a multi-core processor.

[0082] Meanwhile, the processor (230) can provide a game translation inspection service by transmitting and receiving data with the user terminal (100) and processing the transmitted and received data. For example, the processor (230) can receive game screen data from the user terminal (100), extract text data, determine translation errors through a vision model, and generate an error report and provide it to the user terminal (100).

[0083] Hereinafter, with reference to FIG. 4, the process of the processor (230) providing a game translation check service will be explained in detail.

[0084] FIG. 4 is a flowchart illustrating the operation of an electronic device according to one embodiment. Each step (S100 to S400) of FIG. 4 can be performed by the processor (230) of FIG. 3.

[0085] Referring to FIGS. 1 to 4, first, the processor (230) can receive game screen data, which is data for a game screen translated from a first language to a second language, from a user terminal (100) (S100).

[0086] Game screen data is based on screenshot images captured at a specific point in time during game execution and includes various metadata to understand the context of the screen. The processor (230) analyzes the received game screen data to identify the current game progress status, active UI elements, and displayed character information, and this information serves as an important criterion for judgment in the subsequent translation error verification process. For example, since different translations may be applied even to the same words, such as skill description text displayed during combat and item description text displayed in the shop, the processor (230) accurately identifies the current context through game state information. Furthermore, the processor (230) analyzes timestamps, player levels, and ongoing quest information included in the game screen data to identify the story progression stage, and through this, can infer how the relationship between characters or the tone of dialogue should be set at that point.

[0087] Next, the processor (230) can extract text data including multiple texts displayed in a second language from the game screen data (S200).

[0088] The text extraction process involves a high-level processing step that goes beyond simply recognizing characters to accurately identify and structure meaningful text within the complex visual elements of the game screen. The processor (230) first automatically detects areas containing text on the game screen, utilizing a machine learning-based area detection algorithm to identify various UI elements such as buttons, dialogue boxes, menu boxes, tooltips, and floating text. For each UI element, the processor (230) performs a preprocessing step before applying an OCR engine, which includes tasks such as image binarization, noise removal, contrast enhancement, and gradient correction. In particular, since text recognition can be difficult on game screens due to elaborate background images or special effects, the processor (230) clearly separates text areas through adaptive threshold settings and morphological operations. During the OCR process, the processor (230) maximizes recognition accuracy by utilizing open-source engines such as Tesseract OCR as well as cloud-based services such as Google Cloud Vision API or Azure Computer Vision API in parallel. If multiple OCR results differ, the processor (230) selects the most appropriate text through confidence scores and language model-based verification. The extracted text contains not only simple strings but also style information such as font type, size, color, boldness, and italics, as well as accurate pixel coordinates and bounding box information, which are then used to verify text truncation or overflow.

[0089] Next, the processor (230) can determine whether a translation error occurred during the process of translating from a first language to a second language by analyzing text data through a vision model that has been pre-trained based on a neural network (S300).

[0090] This process is a core technical element of the present invention and performs intelligent analysis that goes beyond simple text matching to comprehensively understand the visual context and linguistic meaning of the game. The processor (230) utilizes a large-scale multimodal language model such as GPT-4o to provide game screen images and extracted text simultaneously as input, allowing the model to identify the semantic relationship between visual cues within the image and the text. The vision model analyzes the character's facial expressions, poses, and clothing to identify the emotional tone of the current situation, understands the atmosphere of the scene through the background environment and lighting, and recognizes the genre and style of the game through the UI design and color scheme. Based on this visual understanding, the processor (230) determines whether the translated text is appropriate for the situation. For example, if "Let's have fun!" is lightly translated as "Let's have fun!" in a screen where a character with a tense expression appears in a dark dungeon background, the vision model can detect the discrepancy between the visual context and the text tone and suggest a more appropriate translation, such as "Let's proceed carefully."

[0091] For example, the processor (230) can detect text truncation errors in step (S300).

[0092] More specifically, the processor (230) performs sophisticated spatial analysis to detect text truncation errors. First, it accurately identifies the container area of ​​each UI element on the game screen, which includes the process of extracting the boundaries of buttons, the borders of dialogue boxes, and the ranges of menu boxes in pixels. At the same time, it calculates the area actually occupied by the text displayed within the container to determine whether the text display area extends beyond the container area. The processor (230) does not merely check whether it extends beyond the boundary, but quantitatively evaluates the proportion and importance of the truncation part. The severity differs significantly between cases where the last 10% of the text is truncation and cases where 50% is truncation, and the importance of the error also varies depending on whether the truncation part is a simple particle or a core verb. The processor (230) utilizes a vision model to infer the truncation text and evaluates the degree of semantic loss by comparing it with the original text. For example, it distinguishes between cases where only "nida" is truncation in the text "Exerts a powerful attack power increase effect" and cases where the entire "exerts an effect" is truncation, classifying the latter as a more serious error.

[0093] As another example, the processor (230) can detect an RTL language error in step (S300).

[0094] More specifically, the processor (230) comprehensively examines text orientation and UI mirroring in the layout verification of the RTL language. In a game screen translated into Arabic or Hebrew, the processor (230) analyzes the start and end point coordinates of each text block to verify whether the text is displayed in the correct orientation. It verifies not only the orientation of individual text but also whether the entire UI layout is consistently mirrored. For example, it checks in detail whether the HP bar has been changed from the LTR method of filling from left to right to the RTL method of filling from right to left, whether the order of menu icons has been reversed, and whether the speaker's name in the dialogue box is aligned to the right. The processor (230) evaluates the impact of these layout errors on actual gameplay through a vision model, distinguishing between simple visual awkwardness and serious errors that hinder game progression. For example, an error where the position of the equipment slot in the item inventory is incorrect, making it appear as if armor is equipped in the weapon slot, is classified as a high priority.

[0095] As another example, the processor (230) can distinguish whether the translation discrepancy in step (S300) is an intentional translation change or corresponds to an actual translation error.

[0096] More specifically, the processor (230) applies an intelligent matching algorithm during the comparison process with the translation memory database. It performs fuzzy matching that considers semantic similarity rather than simple string matching, thereby distinguishing between minor differences in expression and actual translation errors. The processor (230) searches for translation cases with similar contexts in the translation memory and calculates similarity using metrics such as cosine similarity or Levenstein distance. If a discrepancy is found, the processor (230) analyzes the overall context of the game screen through a vision model to determine whether the discrepancy is an intentional change or an actual error. For example, if the same term "Critical Hit" is translated differently as "Critical Hit" in the combat screen and "Critical Hit" in the skill description, the processor (230) can classify it as a consistency error by analyzing the overall term usage pattern of the game. Additionally, if multiple translation candidates exist in the translation memory, the processor (230) checks the usage frequency and last modification date of each candidate to select the most appropriate translation and analyzes the difference from the currently used translation.

[0097] As another example, the processor (230) can also verify translation suitability for a language with an honorific system in step (S300).

[0098] More specifically, since verifying the level of honorifics is a critical process, especially in languages ​​like Korean and Japanese, the processor (230) first identifies the relationships between the characters participating in the conversation by referring to the game story and character database. It determines the appropriate level of honorifics by synthesizing information such as age, position, family relationships, and intimacy, which is not a simple rule-based judgment but a complex reasoning process that considers cultural context. The processor (230) analyzes endings, titles, and the use of honorifics in the conversation text to identify the currently used level of honorifics and compares it with the expected level. If a discrepancy is found, the processor (230) analyzes additional visual cues through a vision model. It makes a final judgment on the appropriateness of the level of honorifics by comprehensively considering whether the character's attire is formal or casual, whether the background is a palace or a tavern, and how other characters react. For example, it can detect various levels of honorific errors, ranging from an obvious error where a subject uses informal language in a conversation between a king and a subject, to a subtle inappropriateness where friends use overly casual language in a formal setting. The processor (230) generates specific correction examples for detected honorific errors, not merely adjusting the level of honorifics but converting them into natural conversational language suitable for the character's personality and situation.

[0099] Next, the processor (230) can generate a comprehensive and practical error report based on the judgment result of the translation error (S400). The error report includes detailed information for each detected error, including the type of error, severity, location of occurrence, comparison of the original text and the translated text, suggestions for correction, etc.

[0100] FIG. 5 is a diagram illustrating a text truncation error detection process according to one embodiment.

[0101] Referring to FIGS. 1 through 3 and FIG. 5, the processor (230) extracts a container area representing the boundary coordinates and size of UI elements, including buttons, dialog boxes, and menu boxes containing text, from game screen data as described in claim 2. In this process, the processor (230) applies a computer vision edge detection algorithm, particularly a Canny edge detector or a Sobel filter, to precisely detect the boundaries of the UI elements in pixel units. Based on the detected edges, the processor (230) applies a Hough Transform to identify UI containers in the shape of straight lines and rectangles, and extracts the top-left coordinates (x1, y1) and bottom-right coordinates (x2, y2) of each container to define an accurate boundary area.

[0102] At the same time, the processor (230) calculates a text display area that indicates the coordinates and size of the pixel area actually occupied by the extracted text data. To do this, it analyzes the glyph information of each character to measure the actual text height, including the baseline, ascender, and descender, and calculates the accurate text width, taking into account kerning and letter spacing.

[0103] Next, the processor (230) compares and determines, in subpixel units, whether the text display area extends beyond the boundaries of the container area, but rather precisely analyzes the actual pixel occupancy area of ​​each character rather than a simple bounding box comparison.

[0104] If, as a result of the judgment, it is determined that the text extends beyond the container boundary, the processor (230) uses a vision model to quantitatively calculate the ratio of the extended text to the total text. At this time, the ratio is not based on a simple pixel count, but is subdivided into character units, word units, and semantic units to calculate the respective loss ratios. For example, if 20 pixels are cut off from a text with a total width of 100 pixels, the pixel loss is 20%, but if this corresponds to 1 word out of 5 words, it is calculated as a 20% word loss.

[0105] At this time, if the calculated ratio exceeds a predefined threshold (e.g., 10% based on pixels, 1 or more based on words), the processor (230) further determines whether the core meaning of the original text has been lost by comparing it with the original text of the first language. In this process, the processor (230) utilizes natural language processing techniques to analyze the part of speech of the truncated part and determines whether the part is a main component or a sub-component of the sentence through dependency parsing.

[0106] If the truncated part is an essential component such as a subject, object, or key verb, or contains irreplaceable information such as a number or proper noun, the processor (230) classifies it as a serious text truncation error with loss of meaning and records it as the highest priority in the error report. Furthermore, the processor (230) evaluates the impact of the error by considering the type and importance of the UI element where the text truncation occurred. Truncation of main quest descriptions or tutorial text is classified as Critical level because it has a fatal impact on game progression, while truncation of supplementary descriptions or flavor text is classified as having a relatively lower priority.

[0107] FIG. 6 is a diagram illustrating an RTL language layout verification process according to one embodiment.

[0108] Referring to FIGS. 1 through 3 and FIG. 6, the processor (230) performs comprehensive directional verification when the second language is a right-to-left read RTL language as described in claim 3.

[0109] First, the processor (230) extracts the start and end point coordinates of each of the multiple texts from the game screen data to determine the direction of text progression. This is not a simple coordinate comparison, but a precise analysis using the Unicode Bidirectional Algorithm. In the case of Arabic or Hebrew characters, the processor (230) verifies whether the combined form (isolated, initial, medial, final) of each character is rendered correctly and checks whether the ligature is properly formed. For example, it verifies at the pixel level whether Arabic combinations are correctly displayed as single glyphs and whether special Persian characters are connected in the correct form.

[0110] Next, the processor (230) determines the on-screen placement order and alignment reference point of the UI elements. At this time, the processor (230) examines the consistency of the overall layout mirroring. That is, the processor (230) systematically checks whether the "Back" button on the navigation bar has moved to the right in the RTL environment, whether the order of the tab menu proceeds from right to left, whether the labels of the checkbox and radio button are located on the left, etc.

[0111] If, as a result of the judgment, the text progression direction proceeds from left to right or the arrangement order of UI elements is arranged opposite to the RTL language rules, the processor (230) detects this as a layout error.

[0112] At this time, the processor (230) quantifies and evaluates the extent of the impact that layout errors detected through the vision model have on the user's readability and game progress. The impact evaluation is performed through eye-tracking heatmap simulation, and a cognitive load score is calculated by comparing the typical eye-tracking pattern of an RTL language user (mirroring of the F-pattern) with the actual UI layout.

[0113] Additionally, the processor (230) identifies elements that may cause confusion in gameplay due to incorrect orientation. For example, if the progress bar fills from left to right instead of from right to left, the user may understand the progress in reverse, so this is classified as a High Priority error.

[0114] The processor (230) automatically generates specific correction guides for the correct text orientation and UI layout, suggesting appropriate rearrangement methods that take cultural context into account rather than simply flipping the text horizontally. For example, in the case of a calendar widget, it suggests converting it to the Hijra calendar format used in the Arab region rather than simply flipping it horizontally, or in the case of a time display, it suggests changing it to the format preferred in the region between the 24-hour and 12-hour formats.

[0115] FIG. 7 is a diagram illustrating an error classification process using a translation memory database according to one embodiment.

[0116] Referring to FIGS. 1 through 3 and FIG. 7, the processor (230) queries the original text of the first language and the corresponding standard translation text of the second language from a pre-built translation memory database as described in claim 4. The translation memory database is not a simple key-value store, but is composed of a knowledge graph structure containing rich contextual information for each translation pair. Each entry includes metadata such as the original text, translation text, in-game location (chapter, scene, dialogue ID), speaker information, translator ID, reviewer ID, approval date and time, change history, usage frequency, and a link to a related glossary.

[0117] Next, the processor (230) compares text data extracted from game screen data with standard translation text in string units, and performs similarity-based matching using various metrics such as Levenshtein distance, Jaccard similarity, and cosine similarity, in addition to exact matching.

[0118] When a discrepancy is identified as a result of the judgment, the processor (230) uses a vision model to comprehensively analyze the in-game situation, surrounding UI elements, and character dialogue context in which text corresponding to the discrepancy is displayed. In this process, the processor (230) analyzes the visual elements of the game screen in detail. It identifies the character's emotional state using an expression recognition algorithm, measures the tension of the scene using color temperature and contrast, and determines the importance of UI elements based on size and position.

[0119] Through this multimodal analysis, the processor (230) determines whether the discrepancy is an intentional translation change tailored to the situation or an actual translation error. For example, if the text "Save the princess" is translated differently as "Save the princess" in a rescue mission and as "Save the game" in a save menu, the processor (230) analyzes surrounding UI elements and the game situation to determine that it is an appropriate contextual translation. On the other hand, if the same NPC's dialogue is translated differently without consistency, it is classified as an actual translation error.

[0120] When such actual translation errors occur, the processor (230) precisely classifies the actual translation errors into linguistic errors, visual errors, and complex errors. Linguistic errors are subdivided into grammatical errors (subject-verb mismatch, tense errors), spelling errors (typos, spacing), vocabulary errors (wrong word choice), style errors (inappropriate tone), and terminology mismatch (different translations of the same term). Visual errors are classified into text truncation, overflow, font rendering errors, broken characters due to encoding issues, and inappropriate line breaks. Complex errors include cases where text truncation occurs simultaneously with meaning distortion due to long translations, or cases where the meaning is altered because specific characters are not displayed due to font issues. For each type of error, the processor (230) suggests specific correction directions, including suggestions for AI-based translation improvement, length optimization through text shortening algorithms, and suggestions for UI layout adjustment.

[0121] FIG. 8 is a diagram illustrating a process for verifying the level of honorifics according to one embodiment.

[0122] Referring to FIGS. 1 to 3 and FIG. 8, the processor (230) performs a sophisticated sociolinguistic analysis when the second language is a language with an honorific system as described in claim 5.

[0123] First, the processor (230) identifies dialogue texts containing conversations between characters among multiple texts of game screen data and extracts information on the names, positions, and ages of the characters identified as the speaker and listener. In this process, the processor (230) identifies not only explicitly stated information but also implicit information by referring to the game story database and the character relationship diagram. For example, if character A is the "King of Knights" and character B is the "New Knight," it infers not only the explicit difference in position but also the hierarchy within the organization, the difference in experience, and the mentor-mentee relationship. Based on the extracted information, the processor (230) analyzes the superior-subordinate relationship between characters, the level of intimacy, and the formality of the conversation situation to determine the appropriate level of honorifics. At this time, rather than a simple dichotomous distinction, in the case of Korean, a complex combination of the 7-level honorific system (Hapsi-sip-che, Hao-che, Hage-che, Hae-yo-che, Hae-hae-che, Haera-che, and informal speech) is considered. Additionally, the processor (230) also takes into account situational contexts, reflecting complex social dynamics such as when characters who are usually friends attend an official meeting, when royalty hides their identity and pretends to be a commoner, or when an awkward situation occurs immediately after reconciling with someone who was previously hostile.

[0124] Next, the processor (230) precisely analyzes the endings, titles, and honorific expressions of the conversation text through a morphological analyzer to determine the current level of honorifics. In the case of Korean, it comprehensively analyzes terminal endings (-습니다 / -ㅂ니다, -어요 / -아요, -어 / -아, -네, -지, -거든), nominative case particles (께서 / 이 / 가), titles (님, 씨, 군, 양, 야 / 아), and vocabulary selections (드시다 / 먹다, 계다 / 있다, 돌시다 / 죽다). Even when translated from English to Korean, it determines the level of formality (formal / informal) of the original text and checks whether it has been mapped to an appropriate level of Korean honorifics.

[0125] Next, the processor (230) compares the appropriate honorific level with the current honorific level.

[0126] If inappropriate use of honorifics is detected as a result of comparing the appropriate level of honorifics with the current level of honorifics, the processor (230) re-verifies the appropriate level of honorifics by further analyzing visual cues, including the character's clothing, facial expression, and posture, through a vision model. For example, a character wearing a military uniform is naturally allowed to speak formally, while a character with a drunken expression may be allowed to speak somewhat loosely. The processor (230) identifies the character's emotional state (anger, sadness, joy, surprise) through a facial expression recognition algorithm and measures the degree of politeness (head bowed, upright posture, relaxed posture) through posture analysis.

[0127] If it is finally determined through this multi-layered verification that the use of honorifics is inappropriate, the processor (230) generates an example sentence that converts the conversation text into the correct level of honorifics. At this time, rather than a simple conversion of endings, a natural conversational style is generated that takes into account the character's personality, speech habits, regional dialect, etc. For example, if the character is a superior with a rough personality, a formal style such as "You, come here" is suggested, and if the character is a young and friendly superior, a polite style such as "Hey, come here for a moment" is suggested.

[0128] According to some embodiments, the processor (230) performs the verification of the honorific level of claim 5 by extending it over time. The processor (230) tracks the order in which each conversation proceeds in chronological order in the conversation text containing the conversation between characters. All conversations from the first meeting between characters to the final ending are arranged chronologically along the progression of the game's story, and the patterns of honorific usage at each point in time are stored in a database. The level of honorific between characters set in the first conversation is stored as a reference value; for example, if the knight used the highest honorific, such as "Your Majesty, I will obey your command," during the first meeting between the king and the knight, this is set as the initial honorific relationship of that character pair. If a level of honorific different from the stored reference value is detected in subsequent conversations, the processor (230) checks for the possibility of a change in the character relationship according to the progression of the game's story.

[0129] The processor (230) analyzes whether there is a change in the character's clothing, a change in title, or a transition in the story chapter through a vision model. If a character wearing commoner clothes comes to wear a crown, it is inferred that there has been an elevation in status, and if fancy armor is changed to worn clothes, there has been a downfall. Changes in the background are also important clues; if the background changes from a royal palace to a prison, it is highly likely that there has been a change in the character's status. It also checks whether relationship change events such as "betrayal discovered," "identity revealed," "reconciliation successful," or "wedding" have occurred by checking story event flags. If no elements indicating a change in the character's relationship are found as a result of this analysis, the processor (230) determines that there is inconsistent use of honorifics and suggests correcting the honorifics to a level that meets the standard value. For example, if a knight suddenly speaks informally to the king, saying "Hey, King," without any special event, this is a clear inconsistency error, and it suggests correcting it to "Your Majesty."

[0130] Conversely, if an element indicating a change in character relationship is detected, the processor (230) resets a new level of honorifics suitable for the changed relationship. For example, after an event where the King decides to hide his identity and live as a commoner, excessive honorifics become unnatural, so it is natural to change to an appropriate title such as "Hyungnim." The processor (230) also determines whether this change in the level of honorifics should be gradual or sudden. If the relationship is gradually becoming close, it models a pattern of changing stepwise from "Seonsaengnim" to "Seonbaenim" and then to "Hyung," and if a shocking truth is revealed, it allows for an immediate change in the level of honorifics.

[0131] The processor (230) continuously tracks and verifies whether the new level of honorifics is consistently maintained in subsequent conversations. It detects errors if the previous level of honorifics is used even after the relationship has changed, or if the level of honorifics fluctuates inconsistently at the same point in time. In particular, the processor (230) recognizes that the level of honorifics from the past point in time should be used in flashback or recollection scenes, and verifies the use of honorifics appropriate to the temporal context. Additionally, the processor (230) generates a "level of honorifics change graph" that visualizes the development process of the character relationship throughout the entire story. This graph represents the change in the pattern of honorifics used by each character pair as a line graph, with the X-axis representing the time of the story progression and the Y-axis representing the level of honorifics (levels 1-7). At points of abrupt change, related story events are marked as annotations to support translators and reviewers in easily verifying the appropriate level of honorifics at each point in time and maintaining overall consistency.

[0132] FIG. 9 is a drawing showing an example of an error report generation screen according to one embodiment.

[0133] Referring to FIGS. 1 through 3 and FIG. 9, the interface of the integrated error management system generated by the processor (230) is illustrated in detail. The error report is not merely a list of problems, but consists of a comprehensive dashboard for project management and quality assurance.

[0134] Fig. 9 <a1>The Progress Tracker tracks the progress of error correction in real time, manages the lifecycle of each error, and automatically calculates KPIs. The Progress Tracker tracks the progress of error correction in real time. It manages the lifecycle of each error (discovered-assigned-correcting-reviewed-completed) and automatically calculates KPIs such as average resolution time, reopening rate, and processing status by person in charge. The processor (230) also automatically performs re-verification of the corrected error to check whether the correction has been properly applied and whether new problems have occurred.

[0135] Fig. 9 <a2>The Final Report section provides a visualization of the overall quality verification results and expresses the error distribution by language, chapter, and UI type using heatmaps and charts. The Final Report section visually summarizes the overall quality verification results. The processor (230) expresses the total number of screens inspected, the number of detected errors, the error density (number of errors / number of screens), the error distribution by language, and the concentration of errors by game chapter using charts and graphs. In particular, it visualizes areas where errors are concentrated in the form of a heatmap, making it easy to identify areas that require further review.

[0136] Fig. 9 <a3>The BTS tool integration section supports real-time integration with bug tracking systems such as Jira, Mantis, and Bugzilla, and automatically creates issues and assigns responsible persons for each error. The BTS (Bug Tracking System) tool integration section supports seamless integration with existing project management tools such as Jira, Mantis, and Bugzilla. The processor (230) automatically creates issues for each detected error and automatically assigns appropriate responsible persons according to the type of error. Linguistic errors are assigned to the translation team, visual errors to the UI development team, and complex errors are assigned to both teams simultaneously, and priorities are automatically set according to severity.

[0137] Meanwhile, the error report can be exported in various formats, including official reports in PDF format, detailed data in Excel format, and data for API integration in JSON format. Additionally, the processor (230) periodically generates trend analysis reports to identify trends in quality improvement over time, recurring error patterns, and problem tendencies related to specific translators or developers.

[0138] Referring again to FIGS. 1 through 4, the processor (230) performs a comparative analysis between languages ​​when game screen data is provided in multiple language versions. The processor (230) captures screen data of the first language version and screen data of the second language version at the same point in time of game progression, respectively, and utilizes a game state synchronization mechanism for this purpose. By loading the same save file in each language version or reproducing exactly the same game sequence through a replay system, the processor obtains a screen of the same situation in pixel units. The processor (230) calculates the difference in size of the text display area corresponding to the same UI element in the captured screen data of both language versions in pixel units. At this time, rather than a simple comparison of width and height, the processor comprehensively analyzes the actual pixel area occupied by the text, aspect ratio, number of lines, etc. If the calculated size difference exceeds a preset allowable range (e.g., more than 150% or less than 50% compared to the original), the processor (230) determines whether the text of the second language occupies more space or less space. If the second language text occupies more space, the processor (230) uses a vision model to measure the margin space around the text and the spacing with adjacent UI elements. This is not a simple distance measurement, but a comprehensive analysis that considers minimum margin requirements according to UI design principles, touch target size guidelines, and appropriate spacing for readability. If the calculated maximum expandable area is insufficient to accommodate the second language text, the processor (230) sequentially applies various modification methods to determine the optimal display method. First, a text summarization algorithm based on natural language processing is applied to shorten the text while maintaining its meaning; if that is still insufficient, a line break position optimization algorithm is used to increase space efficiency; and as a last resort, the font size is reduced to the minimum size that maintains readability.The processor (230) simulates the effect of each modification plan and evaluates the readability score and semantic preservation to select the optimal combination.

[0139] On the other hand, the processor (230) applies an intelligent selection mechanism when there are multiple translation candidates for standard translation texts of a second language corresponding to the original text of a first language in the translation memory database. The processor (230) calculates a reliability score by comprehensively analyzing metadata such as the frequency of use, last modification date, approver authority level, and game version used for each translation candidate. The translation candidate with the highest reliability score is selected as the priority standard translation, but the processor (230) also considers the suitability with the context of the current game screen. If the text extracted from the game screen is inconsistent with the selected standard translation but matches another translation candidate, the processor (230) analyzes the character, background, and item information displayed on the screen in detail through a vision model. It identifies the character's costume style, weapon type, and the historical setting of the background to determine whether the current game situation corresponds to a specific event scene or a special dialogue situation. For example, a special translation different from the standard translation may be used in special dialogues during the Halloween event period, hidden ending routes, DLC additional content, etc. The processor (230) verifies consistency by searching for translation patterns of similar situations in the translation memory database. It analyzes the translation styles of other texts used in the same event or similar situations to determine whether the currently used translation matches the overall tone. If consistency is not maintained, the processor (230) suggests a unified translation term to be used in the same situation and cross-references all related text locations to mark them as targets for batch correction. This supports systematic term unification rather than single error correction.

[0140] Meanwhile, the processor (230) tracks the temporal flow of conversations between characters to verify the consistency of the level of honorifics. The processor (230) constructs a timeline of the game story and maps the point in time when each conversation occurs to sort the conversations in chronological order. The level of honorifics between characters set in the first conversation is saved as a reference value and managed as the "honorific relationship profile" of the corresponding character pair. If a level of honorifics different from the saved reference value is detected in subsequent conversations, the processor (230) first checks for the possibility of a change in the relationship as the story progresses. To do this, it analyzes various visual changes through a vision model. It checks whether the character's clothing has changed from commoner's clothes to noble's clothes, whether status indicators such as rank insignia or medals have been added, or whether titles or ranks have changed. It also checks story event flags to determine whether important relationship change events (betrayal, reconciliation, promotion, marriage, etc.) have occurred. If no elements indicating a change in the character relationship are found, the processor (230) determines this as inconsistent use of honorifics and suggests correcting it to a level of honorifics that matches the reference value. Conversely, when a change in relationship is confirmed, the processor (230) resets a new level of honorifics suitable for the changed relationship and updates it to a new reference value from that point onward. It continues to track whether the new level of honorifics is consistently maintained in subsequent conversations, and models a step-by-step change pattern of the level of honorifics if a gradual change is required (e.g., a relationship that gradually becomes close). The processor (230) generates a "relationship change graph" that visualizes these changes in the level of honorifics, allowing the development of character relationships throughout the entire story to be grasped at a glance. Through this, translators and reviewers can easily identify the appropriate level of honorifics at each point in time and maintain overall consistency.

[0141] The embodiments described above may be implemented as hardware components, software components, and / or combinations of hardware and software components. For example, the devices, methods, and components described in the embodiments may be implemented using one or more general-purpose or special-purpose computers, such as, for example, 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 and responding to instructions. The processing unit may execute an operating system (OS) and one or more software applications executed on the operating system. Additionally, the processing unit may access, store, manipulate, process, and generate data in response to the execution of the software. For ease of understanding, the processing unit may be described as being used as a single unit, but those skilled in the art will understand that the processing unit may include multiple processing elements and / or multiple types of processing elements. For example, the processing unit may include multiple processors or one processor and one controller. Additionally, other processing configurations, such as parallel processors, are also possible.

[0142] The method according to the embodiment may be implemented in the form of program instructions that can be executed through various computer means and recorded on a computer-readable medium. The computer-readable medium may include program instructions, data files, data structures, etc., either alone or in combination. The program instructions recorded on the medium may be those specifically designed and configured for the embodiment, or they may be those known and available to those skilled in the art of computer software. Examples of computer-readable recording media 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 hardware devices specifically configured to store and execute program instructions, such as ROM, RAM, and flash memory. Examples of program instructions include machine code, such as that generated by a compiler, as well as high-level language code that can be executed by a computer using an interpreter, etc. The configured hardware device may be configured to operate as one or more software modules to perform the operation of the embodiment, and vice versa.

[0143] Software may include computer programs, code, instructions, or a combination of one or more of these, and may configure a processing unit to operate as desired or command the processing unit independently or collectively. Software and / or data may be permanently or temporarily embodied in any type of machine, component, physical device, virtual equipment, computer storage medium or device, or transmitted signal wave so as to be interpreted by the processing unit or to provide instructions or data to the processing unit. Software may be distributed over networked computer systems and may be stored or executed in a distributed manner. Software and data may be stored on one or more computer-readable recording media.

[0144] Although the embodiments have been described above with reference to the limited drawings, those skilled in the art can apply various technical modifications and variations based on them. For example, suitable results may be achieved even if the described techniques are performed in a different order than described, and / or if the components of the described system, structure, device, circuit, etc. are combined or assembled in a form different from described, or replaced or substituted by other components or equivalents.

[0145] Therefore, other implementations, other embodiments, and equivalents to the claims also fall within the scope of the claims set forth below.

Claims

Claim 1 An electronic device that communicates with a user terminal for a user to provide a game translation check service, comprising: a memory that stores at least one instruction; The method comprises a processor that executes at least one of the above instructions, wherein the processor receives game screen data, which is data regarding a game screen translated from a first language to a second language from the user terminal, extracts text data including a plurality of texts displayed in the second language from the game screen data, and analyzes the text data through a vision model pre-trained based on a neural network to determine whether a translation error occurred during the process of translating from the first language to the second language, and generates an error report based on the result of determining the translation error, wherein the processor extracts a container area representing the boundary coordinates and size of a UI (User Interface) element including a button, a dialog box, and a menu box containing text from the game screen data, extracts a text display area representing the coordinates and size of a pixel area actually occupied by the extracted text data, and compares and determines whether the text display area extends beyond the boundary of the container area, and if it is determined that the text display area extends beyond the boundary of the container area, calculates the ratio of the text extending beyond the boundary of the container area relative to the total text using the vision model, and if the calculated ratio exceeds a pre-defined threshold, the original text of the first language Further determine whether the core meaning of the original text has been lost by comparing with the text and record it as a text truncation error in the error report, wherein when determining whether the core meaning of the original text has been lost, the part of speech of the portion extending beyond the boundaries of the container area is analyzed through dependency parsing, andAn electronic device that determines whether a part extending beyond the boundary of the container area is a main component or a subordinate component of a sentence, and if the part extending beyond the boundary of the container area is an essential component including a subject and an object, or includes irreplaceable information including numbers and proper nouns, determines that the core meaning of the original text has been lost, and the processor tracks the error correction progress of the error report in real time to manage the lifecycle of each error and automatically calculate KPIs. Claim 2 An electronic device according to claim 1, wherein the lifecycle of the error consists of the process of error detection-assignment-correction-review-completion. Claim 3 In paragraph 1, the above KPI is an electronic device including the average error resolution time, reopening rate, and processing status by person in charge. Claim 4 In claim 1, the processor is an electronic device that automatically performs re-verification of the corrected error to confirm whether the correction has been properly applied and whether no new problems have occurred. Claim 5 In paragraph 4, the processor is an electronic device that automatically assigns a person in charge based on each detected error type.

Images