anatomy | basic boilerplate for a Node.js Web App | Runtime Evironment library

Unity font management operates on textures to render characters, and needs to be informed what characters to load in order to add them to a font texture, before you can use them while rendering text. Unless you request loading characters outside your example, having characters that exist in a font but don't have info available are due to not having them loaded into a font texture when you query font for their info.

Font.HasCharacter checks if a font you use has character defined - if it returns false, that character doesn't exist in a font and can't be loaded to be used. Example would be checking a non-latin symbol in font that covers only latin characters. Font.HasCharacter returning true means you can load that character to a font texture.

Font.GetCharacterInfo get information about a symbol from currently loaded font texture - so there is a possibility that loaded font may have a character available, but not loaded; this will cause Font.GetCharacterInfo to return false and make character not render if your render text manually. To work around that, you need to request Unity to load characters you will need by using RequestCharactersInTexture - documentation also contains an example on how to handle manual text rendering including font texture updates. Until you have a character loaded, you won't be able to get its font info, since it doesn't exist in currently used Font texture. When calling RequestCharactersInTexture, pass all characters that occur in your text regardless if they're loaded or not - that way you make sure Font won't unload a character that was previously loaded when loading new ones.

When working on a solution to determine where to put line breaks, you may need to take kerning into account - depending on surrounding characters, font may want to use different distance between characters or sometimes even use different glyphs. If you render text manually, make sure to have consistent handling of kerning between calculating linebreaks - no kerning is a good strategy, as long as font you're using doesn't depend heavily on kerning. If you want to support kerning, you should work on substrings instead of single characters and try to find best points of introducing line break for a whole line - width of a line may be different from sum of all character widths that occur in said line.

This information exists but as an internal implementation detail and is not exposed publicly. If you have specific questions please update your question to be more specific and we will be happy to answer.

To make the time below the image, remove

The object references in chrome developer console is "alive".

Consider this example:

In your template, Global should be renamed as Globals

Please refer to the Globals Section link that you already shared.

I suggest:

Globals aren't support for AWS::Serverless::StateMachine at the moment. Some alternative options you can consider:

• Using DefinitionSubstitutions for some values: https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-statemachine.html#sam-statemachine-definitionsubstitutions
• Step Function supports YAML in develop tooling now, so switching from JSON to YAML will save a bit on indentation and braces at least. https://aws.amazon.com/about-aws/whats-new/2021/03/aws-step-functions-adds-tooling-support-for-yaml/
• Use CDK to define your state machine. You can create custom constructs that encapsulate common properties. Obviously this isn't SAM, but you can integrate SAM resources with CDK apps or consider migrating parts of your application to CDK. https://docs.aws.amazon.com/cdk/api/latest/docs/aws-stepfunctions-readme.html

1. The multicodec is related to decoding the value the hash points to, if that makes it easier to understand. Don't worry, no magic hash decoding is happening ;). Remember we're making CIDs, and we can use CIDs to lookup content. However then we have the question of "how do we decode this data we just retrieved?", the multicodec solves that problem for us. Reading From Data to Data Structures might help clear up some confusion.

2. The multicodec prefix allows IPFS to evolve to support new and different encodings for the data that's actually put into IPFS. This refers to IPLD, and you can actually find the answer you're looking for under Links (with information about the codecs under Codecs):

For links we use a CID. A CID is an extension of multihash, in fact a multihash is part of a CID. We simply add a codec to a multihash that tells us what format the data is in (JSON, CBOR, Bitcoin, Ethereum, etc). This way, we can actually link between data in different formats and any link to data anyone ever gives us can be decoded so that it can become more than just a series of bytes.

CID is a standard that anyone can implement, even people that have no other interest in IPLD beyond the need for hash links to different data types can use it.

1. The Dockerfile runs python3.8 -m venv --copies /usr/share/docassemble/local3.8. When it comes time to upgrade to Python 3.9, it will do python3.9 -m venv --copies /usr/share/docassemble/local3.9. How packages are installed inside that virtual environment is up to the developers of Python and pip.
2. The directory site-packages/docassemble/helpers would be the directory for the Python package docassemble.helpers. You could write such a package and publish it on PyPI (the name is not taken yet).
3. You could look at the Installation page and/or the Dockerfile.
4. When you refer to data files in Python packages you can use a fully-qualified reference such as docassemble.familylaw:data/questions/kids.yml. If you write data/static/tweaks.css it will assume you mean a file in the current package. If you just give it a file name (e.g., tweaks.css) it will assume you mean a file in the current package and it will make an assumption about what data folder you are referring to based on the context. If your Python package is called docassemble.familylaw, then the data folder is located at docassemble/familylaw/data inside the docassemble.familylaw package.
5. You could make a Python package called docassemble.helpers and install it, but bypassing docassemble's package installation system by writing files directly to the Python virtual environment is not advisable. Note that docassemble is a cloud application, so a docassemble "server" may be a cluster of machines. The package management system ensures that you can do docker stop, docker rm, docker pull, and docker run, and your server will be up and running again with all the right Python packages, even if the docker pull results in an upgrade from Python 3.8 to Python 3.9.
6. The modules block has nothing to do with the data folder. If docassemble.xyz is listed in a modules block, docassemble runs from docassemble.xyz import * and imports the module's exported names into the interview answer namespace.