Scenes: managing, combining multiples, loading/unloading - both single & additive.

Game Objects: hierarchy, parenting, prefabs, positioning and rotating, both world & local.

Components: scripting, messaging, their relationships with other parts of the engine - important for UI/rendering/physics.

Scriptable Objects: scripting, automating data creation.

Layers: Game Object Layers, Sorting Layers and how they behave under multiple cameras and/or post-processing.

Cameras: render modes, sizing, view ports, ordering, ray casting, combining multiples - even when mixing different render modes.

Canvas: combining, nesting, render modes (Overlay/Screen Space/World Space).

Selectables: Buttons, Dropdowns, Input Fields, Scroll Rects, Scroll Bars, Sliders, Toggles (and Toggle Groups); transitions and how to animate them.

Layout Groups: vertical, horizontal, grid.

Content Size Fitters

Text Mesh Pro: rich text, sizing, editing fonts, sprites inside text.

Graphic Ray Casting

Clipping/Masking: including nested masks.

Raw Images: using render textures to simulate in-game world cameras.

Interfaces: IPointer Handlers and how they interact with the Input system, using them to script custom UI components.

Sprites: sorting (groups too), making custom materials (both through shader code & graphs), atlasing, editing, masking, tiling.

Physics: update processing, RigidBodies, Colliders - both triggers and collisions, materials, force & torque.

Lighting (Universal Render Pipeline): light sources, blending, shadows, custom shaders.

Audio Sources: spatializing, effects, queuing, looping.

Mixers: used for splitting audio channels in categories (often Music/SFX/Voice).

Filters & Effects

Unity's built-in editor: lerping properties (fades, movement, coloring), sprites, messaging.

Animator: clips, state machines, properties (triggers, bools, floats).

Rigging: Unity's built-in bone system, SpinePro, Live2D.

Importing: I'm experienced with the importing settings of all the assets mentioned above (such as images & audio). Import settings affect how the assets are bundled, compressed and rendered. For example, proper usage of those settings allowed me to reduce build file sizes by 5x, with negligible visual/audio difference.

Asset bundles: setup, creating, loading (both sync & async).

Addressables: creating, loading (both sync & async), groups, building, validating.

Coding shaders in Unity's HLSL: Example: I can replicate any of the shaders on ShaderToy, they are not written in HLSL but I know how to convert them. I can also code my own effects from scratch.

Creating shaders using URP's Shader Graph: although more limited, Shader Graph offers a more intuitive interface for making shaders. Shader Graph also provides real-time feedback, which speeds up the process of trying new effects/bug-fixing.

Coding custom inspectors/property drawers: These facilitate editing properties/variables, they are very useful when there are non-programmers working in the Unity Editor.

Coding scripts to automate tasks: some projects require frequently downloading files from external servers (such as: downloading translations from GoogleSheets, generating MTL through DeepL), these tasks can often be automated with a small amount of code, which saves the developers a lot of time (and sanity).

Coding scripts to validate assets: on many instances, it's worthwhile writing scripts that verify your project files, searching for inconsistencies/mistakes (such as: missing data, invalid data - e.g.: combat NPC with negative attack damage).

DOTween: very useful for creating simple animations/animation sequences through code, which is often more productive than using Unity's Animation Editor. I use DOTween extensively on my projects.

Odin Inspector: it's more powerful than Unity's built-in Object inspector. This package also speeds up the process of creating custom inspectors/property drawers.

YarnSpinner: although I have made a custom dialogue system (VN style) in the past, nowadays I prefer using YarnSpinner as it's simpler and easier for non-programmers to write dialogue in.

Complex stateless machines capable of evaluating the present/past in order to estimate the best actions it can take, outputting stochastic distributions. Which I sample using RNG - making the AI be generally smart but less predictable.

Genetic algorithms: when a smart and complex AI is desired, genetic algorithms can be a viable time-efficient way of creating such AIs.

Reinforcement learning: using Unity's ML-Agents Package.

Bullet hell arcade shooter (in learning project)

Platformer with Hack & Slash (in un-released project)

Turn-based combat systems (in Bonds of Blood and Spire of Slime)

Dungeon crawler with hexagon-shaped tiles (in Spire of Slime)

Custom dialogue system in VN style, mimicking all of Ren'py's features (in Bonds of Blood) (Spire of Slime uses a simpler system that does not allow rollback)

Powerful save systems capable of saving/loading in almost any state (in every commercial project I worked at)(Spire of Slime also features ironman-gauntlet mode)

Mini-games: quick-time events, slider triggers (in Spire of Slime and other non-disclosed projects)

Everything about the type system: Classes/Records, Interfaces, reference vs value types.

Generics Types: parameters, contraints, classes, interfaces, methods, delegates.

Nullable types (in and out of #nullable enable contexts)

Methods vs Properties, Indexers

Iterators/IEnumerator/IEnumerable

Event handlers, delegates, lambdas, closures

Functional programming: pattern matching, tuples, deconstructing.

OOP concepts: objects, inheritance, polymorphism

Memory management: what allocates on the heap vs stack, how to keep the garbage collector from running during active playtime (which can cause notable freezes on Unity, which has a exceptionally slow garbage collector).

Exception handling, try-catch-finally scopes.

Everything value-type/struct related and it's caveats: moving, cloning, referencing, enumerators, spans, stackalloc, readonly structs, ref structs.

Collections, IEnumerables, LINQ

Strings: interpolation, manipulation, regex, verbatim, literals.

Operators: overloading (equality, greater/lesser), booleans, type testing/matching (as, is), nullability propagation (?:,??,??=)

Async/Tasks

IO(File System) reading/writing

Casting & Type conversions

Reflection

Every single C# keyword, except volatile

Borrow checker: unique vs shared references, moving in/out of variables, validating & invalidating variables, lifetimes.

Heap Allocations, when to use and why: Box<>, Rc<>, RefCell<>, ...

Collections, iterators: Map, Filter, Find, ...

Managing scope: modules, paths, dependencies (crates), type aliasing, re-exports, imports.

String vs &str (and &'static str)

Error handling: Option, Result, panicking.

Traits, impls and generic types: including specially-treated traits from the core library, such as DeRef, Operator traits(Add, AddAssign, ...), From, Into, ...

Tests & unit tests

Macros, using & coding: Derive, Attribute-like, Declarative and Function-like.

The fundamentals: Scenes, Nodes, Signals, Scene Tree, Tweens, Resources, Native Scripts.

Handling input: Actions, signals.

Using almost every single 2D node.

Using almost every single UI (Control) node, themes, rects, anchors.

Singletons (Autoloads).

Memory management: hiding & freeing nodes, loading resources.

Scripting Nodes & Resources, using the Godot-Rust bindings.

Game Design: I designed most parts of my hobby projects (like Spire of Slime). On projects I work on, I often help with small design changes and balancing. I am familiar with common terms/expressions used in game design.

Photoshop/Krita: I can make edits, exports, split layers and even make textures & pixel art, from scratch if necessary.

Sound editing: I can acquire, clean and edit simple audios (like sound effects), using Audacity.

NFTs (Crypto projects are fine as long as they have a clear function, no play-to-earn games)

Sexualized underaged characters

Microtransactions

Forced telemetry (I'm only okay with it if the application explicitly asks the user and they give their consent, no "tiny words" written in the bottom of an EULA)

3rd party advertisement (self-promoting is ok)

Everything Unity/programming-related: Coding, UI, animations, database, etc.

Some UI assets.

Some audio assets.

Designing most game mechanics. (I did receive valuable help)

Managing a small team of 6 individuals, handling the entire hiring process, from scouting to interviewing.

Classic Visual Novel framework, powered by a customized version of YarnSpinner.

Complex and fully-animated turn-based combat system, inspired on Darkest Dungeon and Final Fantasy (a lot of inspiration came from F12).

Top-down, hexagon-based, dungeon-crawling map. Layouts are procedurally-generated.

Character panel: allows the player to upgrade stats after leveling-up, and pick new perks/abilities. Most perks have unique interactions in combat. Each protagonist has a unique perk tree.

World Map: simple point & click interface for choosing destinations.

Save system: allows saving/loading at any given time, including in the middle of combat. Iron-man gauntlet mode.

Classic Visual Novel framework, powered by YarnSpinner.

Day/week simulation system. Players must plan their actions at the beginning of the week: choosing which places to visit, study or work at. They also have to choose which transportation method to use. Every action interacts differently with over 15 different stats the MC has.

Hand-made Visual Novel framework, mimicking most of Ren'Py's features. Including(but not limited to) saving/loading mid-dialogue & rollback.

Hand-made translation tooling, responsible for fetching translations from a Google Sheet. The sheet allows live collaboration, allowing translators of all languages to edit contribute in real time.

Extensive UI.

Fully-animated turn-based combat system with complex mechanics, inspired on Vampire: The Masquerade.

Exploration systems:
----City map allows traveling between locations.
----Inside locations, walking is achieved through a classic point & click interface.

Flexible save system: allows saving/loading anywhere except in the middle of combat.

Per hour: My preferred type.
"Per hour" erases my worry about re-negotiating quotes, allowing me to focus solely on doing my best. With this method, you can also request changes anytime.
Accurate predictions are hard to make, but I still advise my clients on the scope of their project, explaining what is/isn't achievable with their budget.

Per delivery: To accommodate potential revisions, I will likely include a buffer in my quotes.

By contract

Western Union

Bank Transfer

Crypto (5% extra fee)

Programmer only: You give me all the details I need, and I'll deliver the code you requested. You'll have to handle everything else: Design, Art, Audio, Writing, e.t.c. Usually I fill this role when the client already has everything else figured out, and only need a programmer to tie everything together.

Producer/Programmer: This is the usual choice for clients with high budget to spare, but little time to work on the game. You only have to explain to me how you want your game to be like, I'll handle everything else:
----Programming.
----Finding/managing talent to fill the other roles: Art, Audio, Writing, e.t.c.

This is the position I fill on Spire of Slime.

During development, all you'll have to do is review the designs/art/playtesting builds to ensure we are going in the direction you want.

Q: Can you code X feature?
I've had many ask me similar questions about a variety of features. Usually the answer is yes, I really enjoy trying new things. The only thing to consider is budget: complex mechanics take exponentially more time to code than simple ones, especially if they are interacting with many other systems.

Q: Why does your price varies so much between different services?
A: I charge less for things I enjoy working on, and more for things that exhaust me.

Example: my rate for developing in Godot-Rust is $25/hr, while Unity is $35/hr. Working with Unity isn't pricier because I'm better at it, it's because I really enjoy working with Rust.

I can work on code for hours while suffering little exhaustion. On the other hand, mentoring requires full attention during the entire session, and to be constantly talking. I don't charge more for tutoring because I don't enjoy teaching (in fact, it's my second-favorite kind of work), I charge more because it's a lot more tiring.

Q: How does your licensing work?
A: The prices mentioned in Services & Rates include a perpetual, non-revokable license to use the provided code in any number of commercial/non-commercial projects. But I still retain the right to re-use that code on my other projects (including other clients). If you want exclusivity, I'll treat it as an NDA - which leads to higher rates.

Q: Do you accept SFW projects?
A: Yes, I have no problems working on either SFW or NSFW projects.

Q: What kind of games you prefer working on?
A: I'm willing to work on pretty much any project as long as it meets my criteria on the About/Disclaimers section. But I have preferences: generally, I prefer games that integrate the lewd parts into gameplay mechanics(instead of just treating them as rewards, like gallery hunters).
Here's a few genres I would like to work on in the future:
----Platformers: although I did work on some prototypes, I was never part of a full-fledged platformer game, and would like to work on something similar to Eroico or Future Fragments.
----Turn-based combat: just like Spire of Slime, I enjoy games that feature sex during battle, making it a integral part of the gameplay.
----Strategy: I really enjoy strategy games and would like to make one in the future. My favorite is Attack It! Devil legion.
----Procedural generation, dungeon crawling, rogue-like: these are elements that don't necessarily define the main genre of a game, but I enjoy working on systems that require complex algorithms.

Q: I want to make a game, but I have no idea how to start... Help?
A: I can definitely help you get started, giving you a direction. But here's a few general tips for absolute beginners:
----Start small, really small: I know you might have read this over and over, but people repeat this so much because it's valid advice, I personally had quite a few issues from ignoring it. Motivation plays a big role in your game development career, and failing a project because "it got too big for you" is a common way of killing all your motivation, giving your career an early end.
----Make a dirty prototype: even a complete beginner can get something done in something like RPG-Maker within 30 days. Having a prototype, even if basic, is a very good way of sharing/developing your vision.
----Study your favorite developers: game developing is a profession that is over 30 years old, and there's a lot of material out there that goes into depth about how experienced developers made their games. You'll find information about common pitfalls, dos and don'ts, e.t.c. Understanding the processes involved will be immense-fully helpful on your journey.

Q: Do you accept revenue share-based employment?
A: No.