apidemo / Lockval Engine

Lockval Engine is free Game backend engine

Lockval Engine is a distributed backend key-value engine that can run scripts.

You can download it to build your own server

On the server side, you can write in the following languages:

Javascript/TypeScript, Go, Lua, Starlark(like Python)

We now provide TypeScript libraries for clients,

and will gradually provide support for more environments in the future

You can learn how to build your app with Lockval Engine here.

This site(source) is built using Lockval Engine itself

▼ Client Code

your entry code:
guestname = // refresh takes effect

import { Player } from "./player";
let player = new Player();
player.guestname = guestname;
player.Open(null);

In player.ts you can check your UID

console.log(this.userData.UID);

After successful login, this text will be replaced by UID

▼ main.json (config)

▼ Server Basic Code
When loading a new server-side script, this json code is called first. You can preprocess json data here and return new json data
• • •

After calling the json code, the public code will be executed. Here you can set which prefix UIDs expose which fields.
• • •

Run this code when user logs in.
• • •

When the front end executes the 'Watch' command, this code will be executed, and the returned Boolean value determines whether the 'Watch' command is allowed
• • •

▼ The following uses several examples to explain the functions and usage of each API, click to expand to view

request, response and Json

This example will show you how to read user input and Json file and return them to the client
keywords: input.Requ, input.Json
The Json file is main.json, you can display it directly on the button above
When you execute:

npm run serverJsBuildAndUpload
npm run serverLuaBuildAndUpload
npm run serverStarBuildAndUpload
npm run serverGoBuildAndUpload

The above script will first upload main.json and then upload the server script
Please note: If you want the Json file to take effect, you must change the server script.

• • • --- obj:{ param1: string, param2: number, param3: boolean, }

read and write kv

this is a read and write kv example, Count increments by 1
keywords: GetSubVal, GetAndLock, PutSubVal, PutAndUnlock

• • • --- obj:{ }

KeySub: mBase

old( onchange_mBase .. let oldV .. )	change( onchange_mBase .. let chgV .. )	new( contextObject.ChangeName=="mBase" .. )

list queue mode

In order, push data to the end of the list, and excess data will shift out from the front
keywords: List(

• • • --- obj:{ first: string, second: string, }

KeySub: mList

old( onchange_mList .. let oldV .. )	change( onchange_mList .. let chgV .. )	new( contextObject.ChangeName=="mList" .. )

list stack mode

First pop up the n pieces behind the old data, and then push data to the end of the list
keywords: List(

• • • --- obj:{ n: number, }

KeySub: mList

old( onchange_mList .. let oldV .. )	change( onchange_mList .. let chgV .. )	new( contextObject.ChangeName=="mList" .. )

clear data

Clear data before doing anything
keywords: Clear(

• • • --- obj:{ }

KeySub: mList

old( onchange_mList .. let oldV .. )	change( onchange_mList .. let chgV .. )	new( contextObject.ChangeName=="mList" .. )

get all data

There are two ways to get all the data

GetSubVal(input.UID, “mList”)
GetSubValAll(input.UID, “mList”)

other api: DiscardAndUnlock

like PutAndUnlock, but does not modify any data

• • • --- obj:{ }

put link

Associate other KeySub when putting data
keywords: Link(

• • • --- obj:{ first: string, second: string, }

KeySub: mList

old( onchange_mList .. let oldV .. )	change( onchange_mList .. let chgV .. )	new( contextObject.ChangeName=="mList" .. )

KeySub: mListSlave

old( onchange_mListSlave .. let oldV .. )	change( onchange_mListSlave .. let chgV .. )	new( contextObject.ChangeName=="mListSlave" .. )

throw a user error

like read and write kv, but execution is interrupted.
keywords: Throw(

• • • --- obj:{ }

KeySub: mBase

old( onchange_mBase .. let oldV .. )	change( onchange_mBase .. let chgV .. )	new( contextObject.ChangeName=="mBase" .. )

advanced query

In addition to GetSubVal and GetSubValAll, we also provide other query methods.
keywords: Group, Len, Max, Min, Random, Range, Search, Sum, Unique

• • • --- obj:{ }

Prepare a globalChat struct

Sometimes, we need to develop some interactive services, such as chat system. At this time we need to watch a public UID and modify it when needed.

In the client
1. we need to define which keys this structure contains. These codes are somewhat similar to player.ts.
In the server script(Check out the code in “Server Basic Code” above):
1. Write the “watch” file. According to your own needs, judge whether this call can be allowed
2. Write the “public” file. Let lockval know which fields can be synchronized to the client

After the above preparations, you can execute player.Watch to watch a public UID. You can see the data change in the example below

•

send A message to globalChat and trigger cron

Please click Watch in the example above before Call

Add data to globalChat:the001. This way users watching globalChat:the001 will see the changes

The cron functionality for triggers is also demonstrated here. For configuration, see the config.yaml of the server.

It demonstrates the action of two bots sending messages periodically.

about cron, you can see: https://lockval.com/docs/architecture/trigger/

• • • --- obj:{ text: string, }

"globalChat:the001" KeySub: mChatList

old( onchange_mChatList .. let oldV .. )	change( onchange_mChatList .. let chgV .. )	new( contextObject.ChangeName=="mChatList" .. )

"globalChat:the001" KeySub: mChatID

old( onchange_mChatID .. let oldV .. )	change( onchange_mChatID .. let chgV .. )	new( contextObject.ChangeName=="mChatID" .. )

Delayed execution of calling code

Execute “sys/testItsTime” after setting 3 seconds
keywords: Sleep
Please pay attention to the data changes in the example below

• • • --- obj:{ }

Delayed execution entity code

do something when it’s time
Here’s the Sleep call from the example above

• • •

KeySub: mBase

old( onchange_mBase .. let oldV .. )	change( onchange_mBase .. let chgV .. )	new( contextObject.ChangeName=="mBase" .. )

Use api.*.so for more functionality

Generate api.*.so files by writing plug-ins to support more functions for server-side script codes
When the api starts, it will search for api.*.so and add all of them to become available functions of the script
This “lockval” plugin can click here to view the source code
keywords: .G[

• • • --- obj:{ }

get link

Associate other KeySub when getting data
keywords: Link(

• • • --- obj:{ }

Get user data before GetAndLock

In lockval, the data in each user call is ACID.

This means that there can only be one GetAndLock call per call to guarantee ACID.

So how to solve the dynamic acquisition of user data through the current user data in GetAndLock?

The method is to notify the front-end engine to upload the specified fields of the current user according to a specific call name. When the backend engine calls GetAndLock, it will check whether these fields are consistent with the current user field data. If not, GetAndLock will return a UserError=-1 to indicate that the data is out of sync

The call name use the “-” symbol to express a group of primarykey_subkey requests

For example: when you want to get the subkey “Count” in the primary key “mBase” before GetAndLock
Then the call name is written as: testKeysCount-mBase_Count (of course testKeysCount can be written as other names)

In addition, lockval also supports reading the value of a parameter (must be of string type) in the request as the key of the subkey.

For example: you want to use the value of your parameter “param1” as a subkey, and “mList” as a primary key. Then the call name is written as: testKeysCount–mList_param1_ (of course testKeysCount can be written as other names, note that there is a “_” at the end, don’t miss it)

If you have requirement 1 and requirement 2, then your calling name should be: testKeysCount-mBase_Count-mList_param1_

The current example will record the value of mBase.Count as the number of subkey in mDict, and if param1=“a”, then it will also record the value of mList.a as the number of subkey in mDict

Note: param1 fills in a subkey in mList, for example: 0000000000000000000001

Note: “func (e export) Export_…” in Go Script use __ instead of -

• • • --- obj:{ param1: string, }

KeySub: mBase

old( onchange_mBase .. let oldV .. )	change( onchange_mBase .. let chgV .. )	new( contextObject.ChangeName=="mBase" .. )

KeySub: mList

old( onchange_mList .. let oldV .. )	change( onchange_mList .. let chgV .. )	new( contextObject.ChangeName=="mList" .. )

KeySub: mDict

old( onchange_mDict .. let oldV .. )	change( onchange_mDict .. let chgV .. )	new( contextObject.ChangeName=="mDict" .. )

▼ Below is a demo of the "trigger" service.
You can only test it in your own local environment.
'trigger' can initiate the execution of script functions via http. In this way, a function similar to recharge callback can be realized
Copy the code to the console for execution, and find that the value of Count has changed.

fetch("http://127.0.0.1:59102/call?chk=3333&uid=After successful login, this text will be replaced by UID&cmd=sys/testItsTime",{method: 'POST',body:JSON.stringify({n:1})})