XINCGer/Unity3DTraining

This repository is a comprehensive collection of Unity development tutorials, utility scripts, and design pattern implementations, primarily focused on C\# and Lua integration. It provides practical examples for core game systems such as asset bundle management, hot updates, networking with Protocol Buffers, and native platform SDK integration. Additionally, it serves as a reference library for software engineering concepts, containing complete codebases for standard design patterns and various editor extension tools.

94 changes.

This period focused on populating a comprehensive repository of Unity training projects and technical demonstrations, covering game mechanics, UI systems, and performance optimization. It also involved the systematic implementation of standard GoF design patterns in C\# and the exploration of advanced topics like hot updates, native integration, and network programming.

40 changes.

This period focused on building a comprehensive suite of Unity editor extensions, asset bundle management frameworks, and data conversion utilities. It also involved developing various demonstration projects for networking, animation, and rendering to support learning and integration efforts.

6 changes.

This period focused on developing a suite of Unity editor extensions and automation tools, including a UI auto-binding framework and a code exporter for cross-environment communication. Additional features included an asset import pipeline for FBX optimization, a utility for unpacking TexturePacker atlases, and a basic node editor demo. The work also involved scaffolding initial projects for XLS to C\# conversion utilities.

Added a new C\# example demonstrating the Bridge design pattern within the DesignPatterns/BridgePattern project. The code separates an abstraction (department course selection) from its implementation (specific math courses) to allow independent variation, and includes a README explaining the pattern's definition and benefits.

DesignPatterns/BridgePattern · high confidence

Introduced the ColaPlus plugin, a Lua library for advanced object-oriented development. The new ColaPlus.lua module provides utilities for type checking, reflection, and object management, configurable via a separate config module. A README file was also added to document the plugin.

SomeTest/ColaPlus · high confidence

Added a new C\# project demonstrating the Iterator design pattern, including the abstract Aggregate and Iterator interfaces, their concrete implementations, and a Program entry point that iterates over a collection of items. The addition also includes a README explaining the pattern's definition and use cases.

DesignPatterns/IteratorPattern · high confidence

Added the KnapsackSystem.sln solution file and README.md documentation for the UGUI Knapsack System. The solution configures the KnapsackSystem.CSharp project for Debug and Release builds, while the README introduces the system's features, including item storage, information tooltips, and drag-and-drop swapping, along with preview images.

UGUITraining/KnapsackSystem · high confidence

Added a new Mediator Pattern example in C\# that demonstrates decoupling object interactions through a central mediator. The solution includes two distinct scenarios: a generic colleague communication model (ColleagueA/ColleagueB via ConcreteMediator) and a customer support simulation (Customer/Techician via CustomerServericeMM). The entry also includes the project solution file, configuration for .NET Framework 4.5.2, and a README explaining the pattern's definition, benefits, and use cases.

DesignPatterns/MediatorPattern · high confidence

Added a new C\# example in the DesignPatterns/MementoPattern directory that implements the Memento design pattern. The solution includes a GameRole class that captures its internal state (level, coordinates, HP, MP, chapter) into a GameState memento, allowing the role to be restored to a previous state via a GameStateCaretaker. It also includes a generic Originator/Memento/Caretaker implementation to demonstrate the pattern's core mechanics.

DesignPatterns/MementoPattern · high confidence

This change introduces a new C\# project demonstrating the Prototype design pattern. It includes an abstract base class and a concrete prototype for shallow copying, as well as classes illustrating both shallow and deep cloning behaviors for complex objects containing nested reference types.

DesignPatterns/Prototype · high confidence

This change introduces a new Unity project structure for testing Bezier curves, including a dedicated scene (2RankScene.unity) and a C\# script (Bezier.cs). The script implements a quadratic Bezier curve calculation using three control points and renders the resulting path via a Unity LineRenderer component, updating the visual output every frame.

BezierTest · high confidence

The MusicDemo scene now includes a script that allows users to pause and resume the game, which transitions the main audio mixer to a paused state, and a slider to adjust the 'drama' level, switching between different music mixer snapshots. The demo also features eight distinct audio tracks (pads, strings, cymbals, snare, trombones, concert drum) and updates the background color based on the selected drama level.

SomeTest/MusicDemo · high confidence

The application now supports undo and redo operations on text changes within the main text box. This is implemented using a command pattern where each text modification is recorded as a command, allowing users to reverse or reapply changes via dedicated Undo and Redo buttons.

SomeTest/UnDoReDoByCommand · high confidence

The xls2csv utility is introduced to convert .xls and .xlsx files into .csv format. It includes a configuration file (config.ini) for setting input and output paths, and provides two script versions: xls2csv.py for older Python environments and xls2csv\_3.0.py, which is updated to support Python 3.4 and later, featuring proper encoding handling and absolute path resolution.

XlsxTools/xls2csv · high confidence

This change introduces a new C\# project demonstrating the Abstract Factory design pattern. The implementation provides a factory interface (IFactory) that creates families of related objects—in this case, specific types of bread (BlackBread, HoneyBread, WhiteBread) and pizza (BlackPizza, HoneyPizza, WhitePizza)—allowing users to switch between product families (e.g., BlackBreadFactory, HoneyBreadFactory) without specifying their concrete classes.

DesignPatterns/Factory/AbstractFactory · high confidence

This location introduces a C\# implementation of the Adapter design pattern, specifically demonstrating how to adapt 110V and 220V power sources for use with a notebook. The code defines interfaces and classes (\PowerPortAdapter\, \Adapter110V\, \Adapter220V\) that bridge the gap between different voltage standards and a \NoteBook\ consumer, along with a generic \Target\/\Adaptee\ example to illustrate the structural pattern.

DesignPatterns/AdapterPattern/AdapterPattern · high confidence

The SDK base module now includes the necessary Android platform files to support integration within Unity. This adds an AndroidManifest.xml declaring the main activity with the Unity player marker and a no-title-bar theme, alongside a compiled SDKBase.jar plugin, launcher icons, and standard Android resource layouts and styles required for the native Android side of the SDK.

SDK/SDKBase/SDKBase/Assets/Plugins/Android · high confidence

The \com.mx.sdkbase\ Android library module has been added to the SDK. It provides a \MainActivity\ that extends \UnityPlayerActivity\, enabling bidirectional communication between Unity and Android. The module exposes specific Java methods for Unity to call, including arithmetic operations (\Sum\, \Max\, \AddOne\), UI feedback via Toast (\MakeToast\), and a callback mechanism (\CallUnityFunc\) to send messages back to Unity. The module is configured to target Android API level 17.

SDK/SDKBase/Android, SDK/SDKBase/Android/com.mx.sdkbase · high confidence

This change introduces the AssetBundleFrame 5.4 solution, providing a basic framework for publishing, updating, and loading asset bundles in Unity. The package includes a Visual Studio solution with C\# projects and a set of sample assets (UI prefabs like Loading and MenuUI, and audio files) organized into asset bundles. It also adds the DOTween animation library (including version-specific extensions for Unity 4.3, 4.6, and 5.0) as a dependency to support tweening capabilities within the framework.

HotUpdate/AssetBundleFrame5.4 · high confidence

Introduced a new Builder Pattern implementation in the DesignPatterns/BuilderPattern directory, featuring a C\# solution targeting .NET Framework 4.5.2. The code demonstrates the pattern using a 'Teacher' (Director) and 'Student' (Builder) analogy to construct complex objects step-by-step, including specific concrete builders (StudentA, StudentB) and a Product class, along with explanatory documentation in README.md.

DesignPatterns/BuilderPattern · high confidence

Added a new C\# demonstration project under SomeTest/SocketDemo that includes a solution file and three sub-projects: a SocketClient and SocketServer pair that communicate over TCP on localhost port 6666, and a NetworkStreamDemo that connects to www.baidu.com on port 80 to read incoming data. The project targets .NET Framework 4.5.2 and provides example implementations for synchronous socket operations and network stream reading.

SomeTest/SocketDemo · high confidence

Added five new C\# files demonstrating different singleton pattern variations: AttributeSingleton (property-based), EagerSingleton (eager initialization), LazySingleton (basic lazy initialization), SyncLazySingleton (double-checked locking for thread safety), and UnitySingleton (Unity MonoBehaviour-based). These files provide code examples for users to understand and implement singleton patterns in C\# and Unity contexts.

DesignPatterns/Singleton · high confidence

A new C\# console application (ConsoleApplication1) has been added to the SomeTest/SortDemo location. This project demonstrates sorting a list of custom data objects based on an enum state property (MyState) using a custom comparison delegate, targeting the .NET Framework 4.5.2 runtime.

SomeTest/SortDemo · high confidence

A new C\# application (ProcessBat) has been introduced that demonstrates how to launch external .bat and .exe files from a .NET Framework 4.5.2 project. The solution includes a sample batch script (test.bat) and a C\# entry point that uses the System.Diagnostics.Process class to run the script with the console window hidden (CreateNoWindow = true).

SomeTest/ProcessBat · high confidence

This change introduces a complete example for calling native C++ code from Unity. It includes the source for a C++ dynamic link library (MyDLL) containing exported functions like Pow2, along with the necessary Visual Studio project files to build it. On the Unity side, it adds the DLLImportDemo project structure, including the MyDLL.dll plugin asset, a Main scene, and a C\# script (DLLImportTest) that uses DllImport to invoke the native Pow2 function at runtime.

SomeTest/DLLImport · high confidence

Added a new C\# implementation of the Chain of Responsibility design pattern, including the solution file and a README that explains the pattern's definition, benefits, and use cases in Chinese.

DesignPatterns/ChainofResponsibilityPattern · high confidence

Added a new C\# console application demonstrating the Chain of Responsibility design pattern. The project includes an abstract Handler class with three concrete implementations (ConcreteHandlerA, B, and C) that process integer requests based on specific values, as well as an OfficeHandler hierarchy featuring Prefects and Emperor classes to illustrate a real-world approval chain scenario.

DesignPatterns/ChainofResponsibilityPattern/ChainofResponsibilityPattern · high confidence

This change introduces a new Unity Editor tool, CodeExporter, which automatically generates C\# binding scripts (modeled after ToLua) to facilitate cross-environment communication. The tool adds an Editor menu item 'CodeExporter/生成代码' that reads a configuration list (CodeExportSetting) and generates wrapper classes (e.g., Controller\_01Bind.cs) in the Assets/Script/Generate directory. These generated files provide a unified Excecute method that accepts string function names and object parameters, handling type conversion for base types (int, bool, double, float) and casting for others, allowing runtime invocation of specific controller methods.

SomeTest/CodeExporter · high confidence

This location introduces a C\# implementation of the Command design pattern, providing a way to encapsulate requests as objects. The code demonstrates two variations: a simple Invoker/Receiver setup and a Herald-based system that supports queuing multiple commands, executing them in batch, and cancelling specific commands from the queue. This allows users to parameterize objects with different actions, support undo/cancel operations, and decouple the sender from the receiver.

DesignPatterns/CommandPattern · high confidence

This location introduces a C\# implementation of the Composite design pattern, providing a reusable structure for managing part-whole hierarchies. The code defines an abstract \Component\ base class and a \Department\ abstraction, implemented by \Composite\ (branch nodes that manage child lists) and \Leaf\ classes (\StudentOffice\, \TeachOffice\) that represent terminal nodes. The \Program.cs\ entry point demonstrates two specific use cases: a generic tree structure with named leaves and nodes, and a school organizational hierarchy where a root university department manages student and teaching offices, allowing uniform operations like \Show\ (for tree visualization) and \ReportWork\ across the entire structure.

DesignPatterns/CompositePattern/CompositePattern · high confidence

Added a new README explaining the Composite design pattern, including its definition, key concepts (treating individual objects and compositions uniformly), and use cases like file systems. Also added the Visual Studio solution file to structure the project.

DesignPatterns/CompositePattern · high confidence

The project now includes the DOTween animation library (by Demigiant), providing capabilities for tweening Unity objects such as transforms, UI elements, and audio mixers. This addition introduces core runtime assemblies (DOTween.dll, DOTween43.dll, DOTween46.dll, DOTween50.dll) and corresponding editor tools, enabling developers to create and control animations directly from code.

DoTweenTraining/DoTweenProject/Assets · high confidence

Added a new C\# project demonstrating the Decorator design pattern. The implementation includes core pattern components (Component, Decorator, ConcreteDecorators) and a practical example using an Actor and Stylist hierarchy to show how behaviors (like makeup and role display) can be dynamically added at runtime.

DesignPatterns/DecoratorPattern · high confidence

A new Visual Studio solution file (DoTweenProject.sln) has been added to the DoTweenTraining/DoTweenProject directory. This file configures the build environment for the DoTween training project, explicitly defining the Assembly-CSharp.csproj and Assembly-CSharp-Editor.csproj projects and setting Assembly-CSharp.csproj as the startup item for MonoDevelop.

DoTweenTraining/DoTweenProject · high confidence

A new Unity test project named DrawCallTest has been added to demonstrate and measure rendering performance. It includes three scenes (Drawcall1, Drawcall2, Drawcall3) and scripts that instantiate 500 cube objects to test dynamic batching and scaling impacts on draw calls. The project is configured for Unity 2017.3.0f3 and includes a README with preview images of the test results.

SomeTest/DrawCallTest · high confidence

Added a new C\# example demonstrating the Facade design pattern, including a solution file, project configuration for .NET Framework 4.5.2, and source code. The implementation features a generic \Facade\ class that simplifies interactions with subsystems \SubA\, \SubB\, and \SubC\, alongside a specific \FactoryFacade\ example that coordinates \CreamFactory\ and \HoneyFactory\ operations. A README provides an explanation of the pattern's definition, use cases, and benefits in simplifying complex subsystem interfaces.

DesignPatterns/FacadePattern · high confidence

The Fisher\_Yates\_Shuffle project now includes a C\# implementation of the Fisher-Yates shuffle algorithm, providing two extension methods for IList\<T\>: ShuffleWithWhileLoop and ShuffleWithForLoop. This allows users to randomly reorder elements in a list using either a while or for loop structure, targeting .NET Framework 4.5.2.

_SomeTest/Fisher\_Yates\Shuffle · high confidence

Added a new README explaining the Flyweight design pattern, including its definition, use cases (such as managing large numbers of fine-grained objects to reduce memory usage), and implementation details like using a factory for shared access. Also added the corresponding Visual Studio solution file to structure the project.

DesignPatterns/FlyweightPattern · high confidence

This change introduces a new C\# implementation of the Flyweight design pattern, specifically illustrated through a连连看 (tile-matching) game scenario. The code includes the core Flyweight structure (abstract class, concrete and unshared flyweights, and a factory) alongside a domain-specific example using ImageNode and ImageNodeFactory to manage shared image resources. The Program.cs entry point demonstrates how these shared objects are retrieved and compared to determine if two randomly selected tiles match, effectively showcasing memory optimization through object sharing.

DesignPatterns/FlyweightPattern/FlyweightPattern · high confidence

A new .NET Framework 4.5.2 console application has been added to the repository that demonstrates file compression and decompression using GZipStream. Users can run the program to input a file path and choose to either compress the file (creating a .gz output) or decompress a .gz file back to its original form.

SomeTest/GZipStreamDemo · high confidence

This change introduces a new Unity project demonstrating how to draw circles in the Scene view using Gizmos. It includes a \DrawCircle\ MonoBehaviour script that renders a circle outline based on configurable radius, color, and smoothness parameters, along with a \Demo.unity\ scene to visualize the effect.

SomeTest/GizmosDrawCircle · high confidence

The project now includes the Google.Protobuf C\# library (containing core serialization components like ByteString, CodedInputStream, and CodedOutputStream) under Assets/Plugins, enabling Protocol Buffer support. Additionally, a new Unity scene named DEMO.unity has been added to demonstrate socket-based Protobuf usage, specifically handling packet framing scenarios such as splitting and sticking.

(repo-wide) · high confidence

A new C\# demonstration project (ILDemo) has been added to the repository, featuring a solution file, project configuration targeting .NET Framework 4.5.2, and a README linking to an IL code tutorial. The core example in Program.cs illustrates the behavioral difference between passing an integer by value versus by reference (ref), showing how modifications inside called functions affect the original variable in each case.

SomeTest/ILDemo · high confidence

Introduced a new C\# project illustrating the Interpreter design pattern, featuring a solution file and core classes including AbstractExpression, Context, and Message. The example demonstrates two distinct interpretation scenarios: a generic terminal/non-terminal expression hierarchy and a specific use case for classifying SMS messages as normal or potential spam (rubbish) based on keyword detection, accompanied by a README explaining the pattern's definition and applicability.

DesignPatterns/InterpreterPattern · high confidence

This location introduces a new Unity test project (IrregularButton) that enables buttons to respond to clicks only on non-transparent pixels of their sprite. The core logic is provided by the IrregularRaycastMask component, which implements ICanvasRaycastFilter to check pixel alpha against a configurable threshold (alpahThreshold) during raycasting, supporting both Sliced and Simple image types. A simpler alternative, IrregulaButton, is also included, which sets the Image's alphaHitTestMinimumThreshold property. The project includes test scenes (Test1, Test2), a ButtonClickCounter script for logging clicks, and necessary asset metadata.

SomeTest/IrregularButton · high confidence

The JsonDataDemo area now includes a complete example for parsing and generating JSON data in Unity. It introduces the LitJson library (via Plugins/LitJson.dll) alongside Unity's built-in JsonUtility. The demo provides two C\# scripts: JsonDeserialize.cs, which demonstrates parsing JSON into custom model classes (JsonObjectModel, JsonArrayModel) and using the dynamic JsonData API, and JsonUtilityTest.cs, which shows serialization and deserialization using Unity's native JsonUtility. A sample data file (Resources/JsonData.json) containing UI panel configurations is included to support these examples.

NetWorkAndResources/JsonDataDemo · high confidence

Added a new example in SomeTest/Lua\_Class demonstrating how to simulate object-oriented features in Lua. The implementation includes Class.lua for base class definition with metatable-based inheritance, SubClass.lua for derived class support with method overriding, and Main.lua to showcase instantiation and polymorphic behavior.

_SomeTest/Lua\Class · high confidence

Added a new Lua script demonstrating closure concepts, including upvalues, independent counters, shared state between closures, and iterator implementation, along with a README explaining C\# and Lua closures.

SomeTest/Closure · high confidence

This change introduces a new Lua module (timespan.lua) and a corresponding test/demo script (MyTimeTest.lua) within the SomeTest/os\_time directory. The module provides helper functions to parse time strings and calculate the remaining seconds until a specified time, leveraging Lua's built-in os.time and os.date functions. The demo script illustrates usage of these standard library functions alongside the new utility.

_SomeTest/os\time · high confidence

The lua/LuaTraining directory has been populated with a comprehensive set of educational Lua scripts covering core language concepts including variables, data types, control structures, functions, tables, strings, iterators, coroutines, object-oriented programming, modules, metatables, garbage collection, I/O, and error handling. Additionally, a new printExt.lua module was introduced to override the global print function, enabling it to recursively print nested table structures for easier debugging.

lua/LuaTraining · high confidence

The MecanimGDC2013 sample area now includes the core asset structure, featuring a DefaultAvatar model with associated texture maps (normal, color, specular) and an ArmsBodyMask for selective bone animation. Additionally, a set of animation clips has been added to demonstrate character behaviors, including Idle, Run, Dying, Reviving, and HoldLog states.

MacanimSystem/MecanimGDC2013 · high confidence

Added a new test scene named Camera.unity along with supporting material assets (Blue.mat, Red.mat) and project configuration files to the MultiCameraTest location, establishing the foundation for multi-camera testing scenarios.

SomeTest/MultiCameraTest · high confidence

The project now includes the NGUI (Next-Gen UI) asset folder, containing editor preview textures, platform-specific native libraries (FreeType), and a suite of example animation clips for UI elements such as buttons, checkboxes, and window transitions.

_Effective C\#/Delegate\EventTraining · high confidence

A new Joystick component has been added to the project, providing a virtual joystick implementation built on the NGUI framework. This component supports both directional and location-based input modes, exposes public events for joystick movement start, holding, down, and end states, and allows configuration of the joystick's visual radius and circular movement limits.

SomeTest/NGUI-Joystick · high confidence

Added a new C\# example demonstrating the Observer design pattern, including the solution file, project configuration (.NET Framework 4.5.2), and source code for both the classic Subject-Observer structure and a spy-themed variation. The implementation includes abstract base classes for subjects and observers, concrete implementations, and a demonstration program, accompanied by a README explaining the pattern's definition and use cases.

DesignPatterns/ObserverPattern · high confidence

Added a new C\# example project illustrating the Proxy design pattern. The code includes a basic proxy implementation for a generic subject and a specific example using a website proxy to manage user registration, login, and browsing actions on a social network site.

DesignPatterns/ProxyPattern/ProxyPattern · high confidence

Added a new README explaining the Proxy design pattern, including its definition, use cases (such as controlling access or handling expensive object creation), and implementation tips, along with the corresponding Visual Studio solution file to support the project structure.

DesignPatterns/ProxyPattern · high confidence

The SomeTest/ScriptableDemo location now includes a complete Unity C\# sample demonstrating how to create, export, and load ScriptableObject data via AssetBundles. The diff adds a MyData ScriptableObject to hold vector content, a MyExporter editor script to build the AssetBundle from assets, and a Client MonoBehaviour to load and access the bundle at runtime, along with the necessary Unity project files and solution configurations.

SomeTest/ScriptableDemo · high confidence

The SimpleFactory location now includes a complete C\# implementation of the Simple Factory pattern. The solution demonstrates a \BreadFactory\ that instantiates specific bread types (BlackBread, HoneyBread, WhiteBread, and HoneyWhiteBread) based on an enum input, providing a concrete example of how to decouple object creation from usage in .NET applications.

DesignPatterns/Factory/SimpleFactory · high confidence

This change introduces a complete Socket networking module for Unity, including a C\# client and server implementation, a binary data buffer utility, and a Protocol Buffers code generation toolchain. The sample demonstrates how to use protobuf-net to serialize and deserialize network messages (e.g., login credentials) alongside a custom binary stream format, providing a ready-to-use reference for implementing networked features in Unity projects.

NetWorkAndResources/SampleSocket · high confidence

Added a new State Pattern example in the DesignPatterns/StatePattern directory, including a README explaining the pattern's definition and use cases, a Visual Studio solution file, and C\# source code. The implementation features a basic Context/State structure in State.cs that toggles between ConcreteStateA and ConcreteStateB, alongside a Train.cs file that outlines a train state machine with Start, Fast, Slow, and Run states (noting that SlowState and RunState currently throw NotImplementedException).

DesignPatterns/StatePattern · high confidence

This location introduces a C\# implementation of the Strategy design pattern, providing a reusable structure for swapping algorithms at runtime. The code defines an abstract \Strategy\ base class and three concrete implementations (A, B, and C) alongside a \Context\ class that delegates execution to the selected strategy. Additionally, it includes a production-specific example (\ProduceStrategy\) that demonstrates seasonal production decisions (summer vs. winter) and integrates a simple factory pattern within the context constructor to select strategies based on an integer input.

DesignPatterns/StrategyPattern · high confidence

A new Unity demo project (SystemInfoDemo) has been added, featuring a Main scene and a SystemInfoController script. The controller gathers and displays runtime hardware and OS information—including device model, name, type, memory size, operating system, and detailed graphics adapter properties (ID, name, vendor, version, memory, multi-threading support, and render target count)—in a UI text element upon initialization.

SomeTest/SystemInfoDemo · high confidence

Added a new C\# project demonstrating the Template Factory design pattern, which defines an interface for creating objects but allows subclasses to decide which class to instantiate. The implementation includes an IFactory interface, concrete factories for various bread types (Black, Honey, White, and HoneyWhite), and corresponding BreadMaker classes to illustrate how new product types can be added by simply creating new factory and product classes.

DesignPatterns/Factory/TemplateFactory · high confidence

This change introduces the Template Method design pattern to the repository by adding a new README.md file that defines the pattern and outlines its use cases, along with a Visual Studio solution file (TemplatePattern.sln) to structure the project.

DesignPatterns/TemplatePattern · high confidence

Added a new C\# console application demonstrating the Template Method design pattern. The code includes an abstract base class defining a skeleton algorithm with primitive operations, concrete subclasses implementing specific behaviors, and a mobile phone example illustrating how subclasses can customize steps like power-on and dial-up sequences while preserving the overall structure.

DesignPatterns/TemplatePattern/TemplatePattern · high confidence

A new Python script, \unpack\_plist.py\, has been added to the \UnityEditorExtension/Python\ directory to extract individual sprite images from TexturePacker atlas files. This tool parses the associated \.plist\ metadata and \.png\ atlas image to reconstruct and save the original sprite frames, handling rotated frames and source size adjustments, which allows users to recover individual assets from bundled texture atlases.

UnityEditorExtension/Python · high confidence

Added two new console application projects, ThreadDemo and TaskDemo, to the solution to demonstrate .NET threading and task-based concurrency patterns. The ThreadDemo project illustrates creating and managing background threads, while the TaskDemo project demonstrates creating and synchronizing multiple tasks using Task.WaitAll.

SomeTest/ThreadDemo · high confidence

A new TimeManager script and associated project files have been added to the timeScaleTest location. This utility allows users to interactively control the Unity Time.timeScale via keyboard inputs (0, 1, 2) and logs timing data across Update, LateUpdate, and FixedUpdate cycles to help verify time-scale behavior.

SomeTest/timeScaleTest · high confidence

The UIBeta training module now includes a new Animation folder containing Unity Animator Controllers and Animation Clips for several UI components, including a Bunny character, a MainMenu, a Panel, an SF Button, and a Settings window. These assets provide pre-built animation states (such as Open, Closed, and Highlighted) that users can reference to learn how to implement common UI transitions and effects in Unity.

UGUITraining/UIBeta · high confidence

This location introduces a simple UI auto-binding framework for Unity. It adds an editor tool (UIExporter) that scans selected UI prefabs for components like Button, Text, and Image, then generates C\# binding scripts (e.g., UILoginPanel.BindView.cs) that map these components to fields via a UICollection helper. The framework includes base classes (UIBase) for view lifecycle management and a sample implementation (UILoginPanel) demonstrating the generated bindings in action.

UGUITraining/UIViewBindDemo · high confidence

Added two new editor scripts to the project: DebugUILine, which draws blue gizmo outlines around UI elements with raycast targets to aid in visual debugging, and MenuOptionOverwrite, which customizes the Unity Editor's GameObject \> UI menu to create Image and Text components with raycastTarget disabled by default when a Canvas is selected.

SomeTest/UnityEditorTest · high confidence

This location introduces the official Unity Technologies AssetBundle demo project, providing a complete workflow for building, testing, and loading AssetBundles. It includes a C\# AssetBundleServer that serves bundles via HTTP on port 7888, editor menu items for building bundles and players, and the AssetBundleManager high-level API which handles automatic dependency resolution, variant selection, and loading from web, local streaming assets, or iOS on-demand resources.

HotUpdate/UnityTechnologiesAssetbundleDemo · high confidence

A new Unity project named 'About\_Coroutine' has been added, featuring a demonstration of Unity coroutines. The project includes a 'ScreenShotByCoroutine' scene and a 'ScreenShotScript' component that captures the current screen as a PNG image and saves it to the project directory when the 'C' key is pressed.

_SomeTest/About\Coroutine · high confidence

This location introduces a Unity 5.5 project demonstrating how to dynamically load external files on mobile devices. It includes C\# scripts (\AssetBunbleReader\, \XMLReader\, \XMLReaderStreaming\) that show three methods for accessing data: loading from the StreamingAssets folder via WWW, loading from the Resources folder, and loading AssetBundles. The demo is supported by sample XML files in both StreamingAssets and Resources directories, along with Unity scenes and a README explaining the approach.

NetWorkAndResources/MobilePlatformDynamicReadExternalFiles · high confidence

This change introduces a new example project located at PerformanceOptimization/ProfilerExample, designed to demonstrate how to use the Unity Profiler for performance analysis. The project includes two C\# scripts, BaseProfiler.cs and CPUUsageProfiler.cs, which show how to wrap functions with Profiler.BeginSample and Profiler.EndSample to track execution time. It also provides corresponding Unity scenes (BaseProfiler.unity and CPUUsageProfiler.unity) and a README explaining the usage of the Profiler API for custom function sampling.

PerformanceOptimization/ProfilerExample · high confidence

This change introduces a new Unity project (version 5.5.0f3) that serves as a demonstration for using Scripting Define Symbols. It includes a C\# script (ScriptDefineSymbols.cs) and a demo scene (demo.unity) showing how to conditionally execute code based on custom macros (such as SHOEDEBUG, UC, QQ) and Unity editor flags (UNITY\_EDITOR) defined in Player Settings. A Visual Studio solution file and a README linking to a blog post on the topic are also added.

SomeTest/Scripting Define Symbols · high confidence

The repository now includes a Visual Studio solution file (Minecraft.sln) that configures the build environment for the Unity project, referencing Assembly-CSharp and its editor variants. This addition establishes the necessary project structure for compiling the Minecraft training assets within the specified development environment (Unity 5.5.0f3 with VS2013).

Minecraft · high confidence

A new Unity project (version 5.2.1f1) has been added to support testing material swapping. It includes a C\# script (MyScript) that allows exchanging a MeshRenderer's material via an index, along with two sample materials and a test scene.

SomeTest/ExchangeTest · high confidence

Added a sample project demonstrating unit testing in Unity using the Editor Test Runner. This includes a \Player\ class with health management logic, a custom \NegativeHealthException\, and corresponding NUnit test cases (\PlayerTest\ and \PlayerTestWrong\) to verify correct and incorrect behavior. The entry also adds necessary project structure files, including a Visual Studio solution, Unity project settings (version 5.5.0f3), and README documentation explaining the tutorial.

Unit4Unity · high confidence

This change introduces the Visitor design pattern to the repository by adding a README.md file that defines the pattern, lists its advantages and disadvantages, and describes suitable use cases. It also adds the corresponding Visual Studio solution file (VisitorPattern.sln) to structure the project for C\# development.

DesignPatterns/VisitorPattern · high confidence

Added a new C\# project demonstrating the Visitor design pattern through two distinct scenarios: a generic object-structure example using \ConcreteElementA\/\B\ and \ConcreteVisitor\, and a business-oriented example where \FinanceDirector\ and \SaleDirector\ visit \FinancialReport\ and \LogisticsReport\ objects. The implementation includes the necessary visitor interfaces, concrete elements, and an object structure to manage and accept visitors.

DesignPatterns/VisitorPattern/VisitorPattern · high confidence

A new Unity project named WebTest has been added to demonstrate network operations. It includes a WebManager script that uses the legacy WWW API to perform GET and POST requests, upload images, and download audio clips and textures. The project also contains a demo scene, a logo asset, and configuration files for Unity 5.2.1.

NetWorkAndResources/WebTest · high confidence

A new demo project named Xls2CS has been added to the XlsxTools directory, consisting of a Visual Studio solution file and a Program.cs entry point that prints 'Hello World!'. This provides a basic starting point for the tool, though the actual conversion logic is not included in this specific change.

XlsxTools/Xls2CS · high confidence

The Macanim\_Training module now includes a set of new animation clips and associated 3D model resources. Specifically, the system adds animation files for 'Dive', 'Dying', 'Idle2Turn2Idle', 'Idles', 'IdlesWave', 'Jump', and 'JumpUpHigh'. These animations are supported by a new 'DudeAvatar' model and a suite of materials (body, eyes, face, skin, suit, teeth) and textures required to render the character correctly within the training environment.

_MacanimSystem/Macanim\Training · high confidence

This change introduces two new editor tools under the GameObject menu to handle component copying in Unity. The 'Copy Current Components' action copies only the components attached to the selected object, while 'Copy All Components' performs a deep copy, capturing components from the selected object and all its child objects in the hierarchy. This allows users to replicate complex GameObject structures with their full component state onto other targets.

3rdPlugins/CopyAllComponents · high confidence

A new Unity demo project (SDK/PullUpQQGroupDemo) has been added that demonstrates how to open a QQ group join page directly from a game without integrating the full Tencent SDK. The demo includes a C\# script (MyScript) that handles platform-specific logic: on Android, it calls a native Java method via JNI, and on iOS, it invokes a native Objective-C function via DllImport. The project also contains the necessary Unity scene, assets, and project settings to run this standalone example.

SDK/PullUpQQGroupDemo · high confidence

A new C\# project targeting .NET Framework 4.6.1 has been added to demonstrate how to handle exceptions and return values in multicast delegates. The code shows that directly invoking a multicast delegate stops execution on the first exception, whereas manually iterating through the invocation list using \GetInvocationList()\ allows the chain to continue and enables aggregation of return values from multiple methods.

SomeTest/MultiDelegateException · high confidence

Added a new Lua-based utility in the SomeTest/garbage\_code\_generater directory that generates random, nonsensical C\# code snippets. The tool includes a main script (garbage\_code\_generater.lua) and documentation files (README.md and usage instructions) that explain how to run the generator with command-line arguments to output randomized C\# files.

_SomeTest/garbage\_code\generater · high confidence

A new Unity project has been added to display real-time mobile device acceleration values (X, Y, and Z axes) on the screen via an on-screen GUI overlay, aiding in the testing and verification of motion sensor input.

SomeTest/MobileAcceleration · high confidence

This change introduces a new editor window infrastructure within the MultiEditorWindow extension, consisting of a base class (EditorWindowBase), a manager (EditorWindowMgr), a main interface (MainWindow), and a repeatable popup window (RepeateWindow). The system allows users to open multiple instances of the 'RepeateWindow' via the 'Tools/RepeateWindow' menu. These windows are managed by a central manager that tracks open windows, assigns them priorities, and automatically handles focus stacking when windows gain attention, ensuring the most recently focused window remains active. The main window provides a UI to spawn these repeatable windows, which can also spawn further instances of themselves, with proper cleanup of the window list upon destruction.

UnityEditorExtension/MultiEditorWindow/Assets/Editor · high confidence

The uLuaDemo project now includes the native tolua library binaries required for cross-platform Lua-C\# interop. This change adds the Android shared library (libtolua.so) for ARMv7, the iOS static library (libtolua.a), the macOS bundle (tolua.bundle), and the Windows/Linux 64-bit DLL (tolua.dll), along with their corresponding Unity plugin importer metadata to ensure they are correctly included in builds for their respective platforms.

(repo-wide) · high confidence

A new PlayerController component has been added to the Pathfinding/Navmesh module, enabling users to move a character across a NavMesh by clicking on the ground plane. The controller integrates with Unity's NavMeshAgent for navigation and includes logic to handle OffMeshLinks by triggering a physics-based jump animation, allowing seamless traversal of gaps or elevated surfaces within the pathfinding system.

Pathfinding · high confidence

The UGUITraining/UGUIDemo02 module now includes metadata files for the CloseButton, LevelItem1, and LevelItem2 prefabs. These additions support the level selection interface, enabling the game to properly reference and instantiate the UI elements used for displaying and closing level items.

UGUITraining/UGUIDemo02/Assets/Prefabs · high confidence

The project now includes metadata (.meta) files for eight Unity scenes within the UGUITraining/UGUIDemo02 module: CharacterScene, FrameScene, Login, MainScene, SelectLevel, SettingScene, StartScene, and TaskList. These files register the scenes with the Unity engine, enabling them to be loaded and managed within the application's navigation flow.

UGUITraining/UGUIDemo02/Assets/Scenes · high confidence

A new Unity project and scene have been added to demonstrate the behavior of the \IPointerClickHandler\ interface within the UGUI event system. The \SampleScene\ includes a UI hierarchy with parent and child elements, each attached to \ParentHandler\ and \ChildHandler\ scripts respectively. These scripts implement \IPointerClickHandler\, \IPointerDownHandler\, and \IPointerUpHandler\ to log pointer events, allowing users to observe how click events propagate through the UI element hierarchy.

_SomeTest/About\IPointerClickHandler · high confidence

The HotUpdate/uLuaDemo area now includes a complete demonstration of integrating Lua scripting with C\# in Unity. This adds a custom settings configuration (CustomSettings.cs) that defines which Unity types and delegates are exposed to the Lua environment, along with auto-generated wrapper code (Source/Generate/) that binds C\# classes like CSFunctionTest and core UnityEngine components to Lua. The demo provides two C\# test scripts (CSLuaTest.cs and CSLuaTest2.cs) illustrating manual function registration and auto-wrapped binding respectively, alongside Lua entry points (Main.lua) and Unity scenes (RegisterFunctionAuto.unity, RegisterFunctionManual.unity) to showcase bidirectional communication between the two languages.

HotUpdate/uLuaDemo · high confidence

A new Python-based tool has been added to convert Excel (.xls) files into JSON data and C\# mapping classes. The utility reads configuration from \config.ini\ and XML definitions to map Excel columns to specific data types, then outputs the resulting JSON and corresponding C\# classes to specified directories. A batch script is also included to facilitate running the conversion process.

XlsxTools/xls2json · high confidence

This update introduces several new scripts and files into the SomeTest directory. BreakAtlasTool.cs adds an editor utility to split and merge NGUI atlases. DragUI.cs provides a MonoBehaviour for handling UGUI drag-and-drop interactions with pointer events. Laser.cs implements a configurable visual laser effect using LineRenderer with customizable curves and gradients. MyInput.cs offers a basic keyboard input handler for character movement. TestConsole.cs displays error and exception logs in the Unity UI. Additional files include HTML2Text.md for HTML-to-text conversion, UTF8String.lua for UTF-8 string handling in Lua, buildApk.bat for automated Android builds, and peiqi.py, a Python script drawing a pig using the turtle module.

SomeTest · high confidence

This change introduces a new localization module that loads language strings from .txt files (Chinese, English, Japanese) using Unity's Resources system. It includes a \LanguageMgr\ singleton to parse key-value pairs from these text assets and a \TextUI\ component that allows UI Text elements to display localized strings by binding to a specific key.

_I18N\_Localization/I18N\_By\Txt · high confidence

The AssetProcessDemo now includes an editor script (FBXPostProcesser) that automatically optimizes imported FBX models by enabling mesh optimization and compressing animation curve values to three decimal places. The project also adds a sample scene with a directional light and camera, along with standard Unity project settings and a sample model asset.

UnityEditorExtension/AssetProcessDemo · high confidence

The Doc directory has been significantly populated with new reference materials, including a comprehensive guide to Unity platform-specific preprocessor macros, a detailed breakdown of Unity file operation paths across iOS, Android, Windows, and Mac, and an explanation of special Unity folders like Editor, Resources, and StreamingAssets. Additionally, new entries cover C\# HTML parsing with HtmlAgilityPack, IntelliJ IDEA usage tips, TCP socket programming concepts like sticky packets, and regular expression syntax. The collection also now includes extensive interview preparation materials, featuring a full list of Unity interview questions with answers, a summary of interview tips covering AssetBundles and UGUI optimization, and curated lists of questions for Lua, C\#, C++, algorithms, and design patterns.

Doc · high confidence

This change introduces a complete demonstration project for Unity AssetBundle management. It adds a runtime \AssetBundleMgr\ and \AssetBundleLoader\ that support loading bundles from local files, WWW, cache, and UnityWebRequest, along with dependency resolution. Editor-side, a \BundleHelper\ script provides menu commands to automatically assign bundle names and build asset bundles. The project also includes sample scenes (Start, Main), a login UI prefab, and pre-built asset bundles in the StreamingAssets folder to illustrate these capabilities.

HotUpdate/AssetBundleDemo/Assets · high confidence

This location introduces a complete AssetBundle management system for Unity. It includes an editor tool (\BuildeAssets.cs\) to package assets into bundles with chunk-based compression and generate manifest metadata. At runtime, \BundleManager\ handles loading local bundles, resolving dependencies, and downloading updated manifests and bundles from a configurable HTTP server (\http://192.168.1.111/StreamingAssets/\) to support hot updates. Supporting utilities include \HttpUtil\ for asynchronous downloads, \JsonUtil\ for serialization, and \AssetBundleConfig\ for centralizing paths and server addresses.

HotUpdate/AssetBundleFramework · high confidence

The LearnOpenGLDemo application has been added, providing a Visual Studio solution and a suite of C++ examples that demonstrate core OpenGL concepts. The codebase includes implementations for rendering basic geometry (triangles, cubes), applying transformations (rotation, scaling), and managing 3D camera movement via mouse and keyboard input. It also features texture loading and blending using the stb\_image library, shader management via a custom Shader class, and matrix math through GLM, allowing users to interactively explore coordinate systems and rendering pipelines.

LearningOpenGL/LearnOpenGLDemo · high confidence

The Nightmares\_Demo location now includes the foundational asset structure for the demo, including folder metadata for Animation, Audio, Fonts, and Materials. This adds specific audio effects (e.g., Hellephant Death, Player GunShot), background music, the LuckiestGuy font, and a variety of Unity materials (e.g., ArchesMaterial, BatMaterial, HellephantMaterial) required for the scene's visual and audio presentation.

_UGUITraining/Nightmares\Demo · high confidence

This change introduces the foundational structure for the SDKBase module within a Unity project (version 5.5.0f3). It adds the necessary folder metadata and a C\# script, MessageHandler, which establishes the bridge between Unity and Android. The script enables calling specific Android methods (AddOne, Sum, Max, MakeToast) from Unity and handling callbacks (Receive) from the Android side, effectively wiring the initial communication layer for the SDK.

SDK/SDKBase/SDKBase · high confidence

This change introduces the core components for a Unity UGUI-based inventory system. It adds a data model with base Item and specific types (Weapon, Armor, Consumable), a GridPanelUI for managing inventory slots, and GridUI scripts that enable drag-and-drop interactions (including item swapping and discarding). The KnapsackManager orchestrates the system, handling item storage, UI updates, and tooltip display, while an InputDetector provides a debug mechanism to store items via right-click.

UGUITraining/KnapsackSystem/Assets · high confidence

The MultiEditorWindow location now includes the foundational Unity project structure, adding the Assets/Editor directory and a full set of ProjectSettings configuration files (Audio, Physics, Graphics, Input, Quality, etc.). This establishes the necessary environment for the editor extension to function within the Unity 2017.3.0f3 editor.

UnityEditorExtension/MultiEditorWindow/Assets, UnityEditorExtension/MultiEditorWindow/ProjectSettings · high confidence

This commit introduces the complete source code for a new WinForms application demonstrating the Model-View-Presenter (MVP) pattern. It includes the main form (Form1) which hosts UserAdd and UserList user controls, wired to their respective presenters via a singleton ApplicationFacade. The implementation features a User model with a proxy for data management, interfaces for the views, and presenters that handle user interactions (adding users) and update the list view accordingly.

SomeTest/WinFormMVP · high confidence

The SDK/XinGeSDK\_Demo location now contains a complete, default Unity project structure initialized for the XinGeSDK. This includes the standard SampleScene with a Main Camera and Directional Light, along with all necessary ProjectSettings files (Audio, Physics, Graphics, Input, Quality, etc.) configured with default values. This provides the foundational environment required to integrate and test the XinGeSDK.

_SDK/XinGeSDK\Demo · high confidence

This update establishes the foundational assets and scripts for the Minecraft-style game. It introduces a first-person character controller with movement, jumping, and head-bobbing effects, alongside a day-night cycle system that rotates the environment. Players can now destroy blocks by clicking on them, and the game includes a life management system that triggers a game-over state if the player falls below a certain height, with options to restart. The asset library is populated with materials and prefabs for various block types (dirt, grass, stone, glass, gold, etc.), trees, walls, and an environment prefab, along with the necessary UI and scene files to support these features.

Minecraft/Assets · high confidence

This change introduces the foundational assets and scripts for the Fruit Ninja game within the Assets directory. It adds the Prefabs folder containing fruit (apple, lemon, watermelon) and bomb variants, along with the Res folder holding 3D models, materials, particle effects, sound effects, and UI textures. Functionally, it implements the core gameplay loop through three new scripts: GameManager (a singleton for audio control and game state), MouseController (handling mouse input, drawing a slash trail via LineRenderer, and casting rays to detect fruit cuts), and DestroyOnTime (auto-destroying objects after a set duration). It also registers the Menu, Play, and GameOver scenes.

_Fruit\Ninja/Assets · high confidence

This change introduces the foundational structure for the Adapter Pattern example, including a new Visual Studio solution file and a comprehensive README. The documentation explains the definition, use cases, and distinctions between class and object adapters in Chinese, providing users with the conceptual background and context for the design pattern implementation.

DesignPatterns/AdapterPattern · high confidence

The Fruit\_Ninja directory now contains the Visual Studio solution file (.sln) for the Unity project and a README.md file. The documentation specifies the development environment as Unity 5.5.0f3 with Visual Studio 2015 and includes preview images and a download link for the Windows build.

_Fruit\Ninja · high confidence

This change introduces the NodeEditorCollection repository, which serves as a hub for node editor resources. It includes a basic NodeEditor demo component that provides a draggable editor window with two demo nodes and a visual connection curve, accessible via the Tools menu. The collection also lists several external node editor frameworks (xNode, NodeGraphProcessor, Node\_Editor\_Framework, DialogueGraph) and includes a complete default Unity project structure (ProjectSettings, Assets, etc.) configured for Unity 2017.3.0f3.

UnityEditorExtension/NodeEditorCollection · high confidence

This change introduces the foundational project files for the UGUI Demo 02 training module, including the Visual Studio solution file (UGUIDemo02.sln), user preferences, and a README.md documenting the demo's scope (game start screen, skill menu, character panel, inventory, level selection, task list, settings, and login interface).

UGUITraining/UGUIDemo02 · high confidence

This change introduces the initial structure for a UGUI game menu training project, including Unity scene files (Demo01.unity, Game.unity), C\# scripts for game management and player rotation, and supporting configuration files like the Visual Studio solution and project settings.

UGUITraining/UGUIDemo01 · high confidence

This change introduces the initial structure for the GuideSystem, a new Unity project designed to implement a beginner's guide feature for games. The commit adds the complete set of default Unity project settings (including audio, physics, graphics, and input configurations), a basic 'Main' scene with a default camera setup, and a README file that links to a tutorial video for the feature.

GuideSystem, HotUpdate/AssetBundleDemo · high confidence

This change introduces the core components for loading and caching Excel-derived configuration data within the Xls2Lua toolchain. It adds a base Class module for object-oriented structure, a ConfigMgr singleton that reads Lua configuration files from the LuaData directory, caches them, and provides fast lookup by ID, along with a Main entry point demonstrating how to retrieve specific configuration items.

XlsxTools/Xls2Lua/ConfigMgr · high confidence

This change introduces the MultiEditorWindow Unity Editor extension, providing functionality for managing multiple pop-up editor windows and editor window hierarchy. The commit adds the Visual Studio solution file (.sln) for the project and a README.md file that includes preview images and a link to a tutorial blog post explaining the feature.

UnityEditorExtension/MultiEditorWindow · high confidence

This change introduces the core gameplay logic for the SpaceShooter project, adding a complete set of C\# scripts to the Assets directory. The implementation includes player movement and shooting controls (PlayerController), enemy spawning and wave management (GameController), collision and destruction handling (DestroyByContact, DestroyByBoundary, DestroyByTime), and visual behaviors like background scrolling and random rotation (BGScroller, RandomRotator). A README file is also added to document the project and provide preview images.

SpaceShooter · high confidence

This change introduces the SpringBone component, a new capability for simulating dynamic bone physics (such as hair and clothing movement) in Unity. The \SpringBone.cs\ script implements spring-based physics with configurable stiffness, bounciness, and dampness, and includes a \useSpecifiedRotation\ option to lock rotation when not controlled by an Animator. An accompanying \SpringBoneEditor\ provides a custom inspector for tuning these parameters and a scene gizmo for interactive placement of the bone's end point. To demonstrate the feature, the \SpringBone\ subfolder now includes a UnityChan model with various animations (e.g., AR poses, jumps, damage states) and a demo scene.

DynamicBones · high confidence

This change introduces the Xls2Lua utility, a standalone tool that converts XLS spreadsheet files into Lua data files. The addition includes the Visual Studio solution, project assembly metadata, and documentation explaining the tool's usage, directory structure, and configuration via config.ini.

XlsxTools/Xls2Lua · high confidence

Added a new Lua-based event center in the lua/LuaEventMgr directory, providing a singleton manager to register, unregister, and dispatch events with optional parameters. This component enables module decoupling and handles scenarios such as network listening by allowing callbacks to receive event data.

lua/LuaEventMgr · high confidence

A new command-line utility (Xls2Lua) is added to convert .xls files into Lua scripts for game data. The tool reads input and output directory paths from a config.ini file, processes each sheet in the source Excel files, and generates corresponding .lua files in the target directory. It supports various data types (integers, floats, strings, booleans, enums, structs) and array definitions, handling column metadata and content parsing to produce the final Lua output.

XlsxTools/Xls2Lua/Xls2Lua · high confidence

This change introduces a new object pool implementation within the Unity project to optimize memory usage by reusing GameObjects instead of frequently instantiating and destroying them. The core \GameObjectPool\ class manages a dictionary of pooled objects, providing static methods to retrieve active instances (creating new ones if the pool is empty) and store inactive objects back into the pool. A demonstration scene and script (\PoolTest\) allow users to spawn bullets that are automatically returned to the pool after a short delay via the \AutoDestroy\ component, effectively reducing allocation overhead for repetitive objects like projectiles.

_MemoryPool\ObjectPool/Object Pool2 · high confidence

This location introduces a complete JSON-based internationalization solution for Unity applications. It includes the LitJson library for parsing, language resource files (Chinese, English, Japanese) stored in Resources, and the core \LanguageMgr\ script that loads these JSON files and provides text lookup by key. The \TextUI\ component demonstrates how to bind UI Text elements to these localized keys, enabling dynamic language switching based on the system language.

_I18N\_Localization/I18N\_By\_Csv, I18N\_Localization/I18N\_By\Json · high confidence

The 2DPlatformer module now includes a complete set of Unity animation clips for the game's visual elements. This update adds animation data for the player character (Idle, Jump, Falling, Death), environmental objects (Clouds, Fog, Bus), and specific game events (BombLanding, Intro, 100points). These assets provide the motion and visual feedback for the native 2D platformer experience.

2DPlatformer · high confidence

This change introduces three new scripts to the UGUIDemo02 training module: MyToggle, which extends the standard Unity Toggle to manage visibility of associated UI elements based on its state; ScrollListener, which adds horizontal snapping behavior to a ScrollRect (automatically aligning to predefined page positions after a drag) and allows Toggles to control the scroll position; and SkillItem, which implements a visual cooldown timer on an image fill amount triggered by a specific key press or click. These components provide the underlying logic for toggle-driven list navigation, smooth scroll snapping, and skill cooldown visualization within this demo.

UGUITraining/UGUIDemo02/Assets/Scripts · high confidence

Added \AnimOptimization.md\ to the PerformanceOptimization directory, providing a curated list of resources and tools for reducing Unity animation file sizes and precision overhead. Additionally, introduced \TX工作室UI优化文档.md\, a detailed guide on UGUI performance best practices, covering DrawCall reduction strategies, Canvas rebuild triggers, and efficient UI despawn techniques using CanvasGroup alpha instead of SetActive.

PerformanceOptimization · high confidence

The UGUITraining/UGUIDemo02 project has been created with a specific Unity editor version (5.2.1f1) and standard assets configuration. This establishes the baseline environment for the 'Game Start Screen' training demo.

UGUITraining/UGUIDemo02/ProjectSettings · high confidence

A change to existing behaviour in SomeTest/BirthdayCakeModel — 1 commit, 1 file.

Doc/Git, Doc/HTMLEngine, SomeTest/BirthdayCakeModel · low confidence · unverified

The Xls2Lua tool has generated initial Lua data files for language strings and resource path configurations. The new Language.lua file provides access to localized text entries (e.g., '测试文字1'), while ResPathConfig.lua defines mappings for UI assets and textures, including their paths, types, and live times. These auto-generated files enable the application to load language data and resolve resource paths directly from Lua.

XlsxTools/Xls2Lua/Excel, XlsxTools/Xls2Lua/LuaData · high confidence

A new ProjectVersion.txt file has been added to the Minecraft/ProjectSettings directory, establishing the project's target editor version as Unity 5.5.0f3. This sets the baseline environment for the project's settings and ensures compatibility with this specific version of the Unity engine.

Minecraft/ProjectSettings · high confidence

A new ProjectVersion.txt file has been added to the UGUITraining/KnapsackSystem/ProjectSettings directory, explicitly setting the Unity Editor version to 5.5.0f3. This ensures that the project is recognized and opened with the correct Unity editor version, preventing potential compatibility issues or automatic upgrades.

UGUITraining/KnapsackSystem/ProjectSettings · high confidence

Added .csproj build manifests for multiple design pattern implementations (Adapter, Bridge, Builder, Chain of Responsibility, Command, Composite, Decorator, Facade, Factory variants, Flyweight, Interpreter, Iterator, Mediator, Memento) and a Bezier curve test project, enabling these C\# solutions to be built with MSBuild.

(dependencies) · high confidence

Added HotUpdate resource management and hotfix technology reference guide; Added I18N Localization documentation hub; Added UI asset metadata for UGUIDemo02; Added UML class diagram for soccer steering and ball control systems; Added folder metadata for UGUI Demo 02 assets; PhysicsStudy documentation added.

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 47 → 47 (-0.1)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 70 → 75 (+5.6)
• Architecture 95 → 65 (-29.9)
• Maturity 62 → 67 (+4.9)
• Readiness 35 → 35 (+0.0)
• Security 47 → 49 (+1.8)

• Analyzed solution does not cover the bulk of the repository
• Build did not complete in the analyzer
• Duplicated block (14 lines × 2) (Minecraft/Assets/Standard Assets/CrossPlatformInput/Scripts/Joystick.cs)
• Duplicated block (15 lines × 2) (Minecraft/Assets/Standard Assets/Utility/AutoMobileShaderSwitch.cs)
• Duplicated block (17 lines × 2) (Minecraft/Assets/Standard Assets/Utility/AutoMobileShaderSwitch.cs)
• Duplicated block (8 lines × 2) (Minecraft/Assets/Standard Assets/Utility/AutoMobileShaderSwitch.cs)
• High: security finding (details withheld)
• High: security finding (details withheld)
• LLM evaluation failed
• Monorepo: only 1 of 71 solutions was scored
• No exposed public API
• Off the main sequence: Assembly-CSharp-firstpass
• Secret: aws-access-token (Effective C#/Delegate_EventTraining/Assets/NGUI/Examples/Models/Orc/Orc Skin (Diffuse).psd)
• Secret: aws-access-token (Effective C#/Delegate_EventTraining/Assets/NGUI/Examples/Models/Orc/Orc Skin (Diffuse).psd)
• Test reliability not measured — no test run produced results
• Tests co-located / outside the solution
• complexity unreadable for .cs, .fs, .java, .py — churn × complexity hotspots could not be measured
• dormant codebase — no living knowledge left to concentrate
• redundant comment (Minecraft/Assets/Scripts/LifeManager.cs)

• Documentation: no installation or build instructions (README.md)
• Documentation: no project overview (README.md)
• End-of-life runtime: .NET netcoreapp3.1
• Medium: security finding (details withheld)
• Off the main sequence: Delegate_EventTraining.CSharp
• Projects may be oversized for their cohesion
• Secret: aws-access-token (Effective C#/Delegate_EventTraining/Assets/NGUI/Examples/Models/Orc/Orc Skin (Diffuse).psd)
• Secret: aws-access-token (Effective C#/Delegate_EventTraining/Assets/NGUI/Examples/Models/Orc/Orc Skin (Diffuse).psd)
• Test reliability not measured — test suite did not build
• Typo in method name: 'GoogMoring' is a misspelling of 'GoodMorning'. Additionally, the delegate type 'MoringDelegate' is misspelled (missing 'n').
• Typo in property name: 'ambigious' is a misspelling of 'ambiguous'.
• XML-doc coverage: Delegate_EventTraining.CSharp (Effective C#/Delegate_EventTraining/Delegate_EventTraining.CSharp.csproj)
• XML-doc coverage: Delegate_EventTraining.CSharp.Editor (Effective C#/Delegate_EventTraining/Delegate_EventTraining.CSharp.Editor.csproj)
• redundant comment (Effective C#/Delegate_EventTraining/Assets/NGUI/Scripts/Editor/NGUIEditorTools.cs)
• redundant comment (Effective C#/Delegate_EventTraining/Assets/NGUI/Scripts/UI/UIPanel.cs)

• 9 commits — 9 feature/other, 0 fixes

• AI/README.md — 7 commits
• 3rdPlugins/README.md — 1 commit
• CPlusPlus/README.md — 1 commit

• change: DeepWiki
• change: HyperLPR - 高性能中国车牌识别框架
• change: azure-sdk-for-net
• change: bifrost - Fastest enterprise AI gateway (50x faster than LiteLLM)
• change: claude-video - Give Claude the ability to watch any video
• change: deepwiki-open Open Source DeepWiki: AI-Powered Wiki Generator for GitHub/Gitlab/Bitbucket Repositories
• change: grok-build
• change: nano-vllm - A lightweight vLLM implementation built from scratch
• change: scriptc - TypeScript-to-Native Compiler

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

XINCGer/Unity3DTraining was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.