44 Followers

Recent Profile Visitors

@DarkClaw Thanks for all that! (And sorry I didn't see this all sooner.)
I've updated the Ubuntu libxayagame build doc (I knew we should've put in "sudo ldconfig" there just in case) and the Hello World C++ for that single quote.
Regarding the name_update and the bash error, you can use a space, e.g.:
osboxes@osboxes:~/xaya$ ./xaya-cli -rpcuser=user -rpcpassword=password name_update "p/Road Runner" "{\"g\":{\"helloworld\":{\"m\":\"Hello Wile E. Coyote! \"}}}"
d70393029638a494b0771a778d39766e5ea0806f29e0af9a0116d86361e81a73
You can also "set +H" to turn off that ! bash history:
osboxes@osboxes:~/xaya$ set +H
osboxes@osboxes:~/xaya$ ./xaya-cli -rpcuser=user -rpcpassword=password name_update "p/Road Runner" "{\"g\":{\"helloworld\":{\"m\":\"Hello Wile E. Coyote!\"}}}"
0f1c0f5ee32af773a2edb869ed3c5fa75d8e8edc1d53ee169a28118be5aa0ecc
See here for more information on that:
https://serverfault.com/questions/208265/what-is-bash-event-not-found
I've updated the C++ tutorial with a note to help people get around that.
For the Mover move format, it's in 2 places (other than in the C# tutorial):
https://github.com/xaya/xaya_tutorials/wiki/Mover-Console-Tutorial#a-quick-look-at-moves
https://github.com/xaya/xaya_tutorials/wiki/Unity-Mover-Tutorial#making-a-move
The other Mover doc is only a very high-level overview without any details.

I'm not voting there.
My vote is for whatever make most sense in development to push Treat Fighter forward.
I want to see Treat Fighter be successful, so whatever makes most sense for TF has my vote.
We all knew that it was beta testing, so... wherever the cards may land, they land. Beta on any mainnet is risky. We all know that and were willing to play along.
(I do treasure my Bronze Treat Fighter though. I'd like to keep that. I gave away my CHI winnings to other players. It was only that precious, rare Bronze Treat Fighter that I wanted.)
But, if I have to sacrifice that for the future advancement of TF... let it be.
Do whatever gets TF to a final release!
(But I do dearly love my Bronze Treat Fighter!)

In addition to Liquid.com, BitMesh.com is now trading CHI in the following pairs:
CHI/BTC
CHI/USDT
The official BitMesh announcement is here:
https://help.bitmesh.com/hc/en-us/articles/360019567373
BitMesh has no fiat trading, and as such has far less regulatory overhead for KYC/AML. People that previously couldn't register with Liquid can now trade CHI easier with BitMesh.

The XAYA team have been working night & day on development and we have some exciting progress updates for you.
TAURION
"Project X" has finally earned a name: Taurion.
Taurion is a true blockchain game. It runs 100% on the blockchain, serverless and unstoppable. It incorporates the same type of play-2-earn gaming experience that we pioneered in 2013 with Huntercoin, i.e. Human Mining.
Taurion will also incorporate Xaya ID (xid). Xaya ID is a dapp that allows secure, trustless chat and communication.
We're currently running Taurion on regtest and testnet. While it's not ready for the general public, you can find videos of different game-play elements in our first post on Taurion here. More information about the game, the backstory, and game mechanics is available at that link.
DEVELOPMENT
Development is fast and furious. There are continual code commits all the time and you can see them for yourself in any of our GitHub repositories. Keep in mind that there are other private repositories that are continually being updated as well.
Some highlights include:
xid
Xaya Id is a new addition. This dapp turns every XAYA name into a secure digital identity! While there are entire blockchains dedicated to just this 1 feature, on XAYA it's just a dapp, which should help illustrate just how powerful the XAYA platform is.
However, more than just secure IDs, Xaya ID enables secure chat and communications through ejabbered, an enterprise quality solution for massively scalable communications through XMPP, MQTT and SIP.
nsgminer & ccminer
For miners, we've released 2 repos.
Make sure to drop by our Mining forum for help if you need it.
******
Check out the Current Development Status thread for discussions and more information.
DOCUMENTATION
More documentation and tutorials are being added and improved all the time.
Check out the documentation and tutorials wiki here.
******
For both code and docs that you're interested in, make sure to keep your eye on when they were last updated because chances are the next time you look at them, we'll have added some great stuff or made some nice improvements.

I don't know for certain ( @Tricky Fast Mike should probably chime in), but my guess is that TF is looking for the game.dat wallet.
Try restarting xayad with the "-rpcwallet=game.dat" option. That should create a new game wallet for you. You can then send CHI to it from your other wallet.
So, for example maybe try running like this:
xayad -rpcwallet=game.dat -server=1 -rpcallowip=127.0.0.1 -zmqpubhashtx=tcp://127.0.0.1:28332 -zmqpubhashblock=tcp://127.0.0.1:28332 -zmqpubrawblock=tcp://127.0.0.1:28332 -zmqpubrawtx=tcp://127.0.0.1:28332 -zmqpubgameblocks=tcp://127.0.0.1:28332
I've got some more information in the docs & tutorials about running xayad here:
https://github.com/xaya/xaya_tutorials/wiki/Running-xayad-for-Games
It doesn't cover wallet creation though. It's just about running with options for games.

Make sure that you have the game.dat wallet loaded. Try these:
xaya-cli loadwallet "game.dat"
You may not have run xayad with "-rpcwallet=game.dat". Also, try this:
xaya-cli -rpcwallet=game.dat getbalance

Absolutely. There's no reason for any regular user to ever even look at libxayagame. It's a development tool.
For other people, that's about this:
name_show p/john
No. It doesn't show a game state. It shows the data associated with the name, or the last name_update. At the moment, that's this for "p/John" (note the case difference).
{
"name": "p/John",
"name_encoding": "utf8",
"value": "{\"p/John\":\"\"}",
"value_encoding": "ascii",
"txid": "dce27bde307784aea84d1bb1e21e0e958f6af525e85f2a367233c30dd2ae7641",
"vout": 1,
"address": "CTpzhXe4gEN1cP28g2cvujFR9xyh1YwWK1",
"height": 7212,
"ismine": false
}
You can check for more information about name_show here:
https://github.com/xaya/xaya_tutorials/wiki/XAYA-RPC-Methods#name_show

Sending a move to the blockchain is trivial. It takes 4 lines of code total. From the HelloWorld example, these are the lines:
using BitcoinLib.Responses;
BitcoinLib.Services.Coins.XAYA.IXAYAService xayaService;
xayaService = new BitcoinLib.Services.Coins.XAYA.XAYAService("http://localhost:8396/wallet/game.dat",
Properties.Settings.Default.Username,
Properties.Settings.Default.Password,
"",
10);
xayaService.NameUpdate(this.cbxNames.GetItemText(this.cbxNames.SelectedItem), hello, new object());
However, GETTING game states requires much more effort. There's just no way around it. It requires wiring up libxayagame in a thread and getting the data in another listener thread. Threading takes much more code. Also, libxayagame's Connect method is a blocking operation, so if we have an example without threads, then you can never send or receive a move because the main thread is blocked.
This tutorial here is extremely minimalistic and ONLY goes over the absolute minimum needed to wire up libxayagame. It requires knowledge of threading and the callbacks. However, implementing the callbacks is non-trivial and there's no way to do it in just a few lines of code. They're where the core game logic resides.
There are a fair number of requirements, so the project size is fairly large, but the only important file for it is "HelloXaya.cs". Without those other things though, the program wouldn't compile or run.
It's a good point about getting side tracked. I've added a note there. Hopefully it will keep people focused on the important parts.
I've abstracted out basic wiring up, which gives the functionality, in "How to Wire Up libxayagame in C#". But, it's not something that you can compile and run like HelloXaya. All the parts are required to have something that you can compile and run.
The documentation is still a work in progress though. And it certainly helps to get feedback like yours. I'll make sure to include it in forthcoming documentation.

The Hello World tutorial aims to show:
how to wire up an app or game, (video here)
send a move, (video here)
get the game state (video here)
update the UI (video here)
It's not focused on any of the actual game logic, because there really isn't any game logic in Hello World.
Wiring up libxayagame requires at least 2 threads.
Construct and connect to libxayagame
Receive a game state to update the main UI front end
There's no way around that, so that adds in complexity.
The Hello World example doesn't use a third thread to update the UI, but ideally UI updates should be done in 1 or more threads. That would be done in the "UpdateHelloChat" method.
Then there are the 3 callbacks to implement. See below.
Writing is just a simple RPC call, i.e. a name_update. It's pretty trivial. If you know the move, it's 1 line of code. This is the Hello World tutorial about that.
Storing game data is mainly done in 2 ways.
Creating a new game state from moves in the last mined block
Creating undo data to rewind 1 block
Once that data is created, it's returned inside the forward callback and effectively stored by libxayagame as it will pass back that data in both the forward and backward callbacks. Data can also be stored using SQLite or lmdb. Tutorials on those will be coming later.
Accessing data is done through 1 of the threads mentioned above when wiring up libxayagame. The "Listening for New GameStates" part in the Hello World tutorial addresses that.
For the "game logic", that's done in the forward and backward callbacks. We'll have tutorials for that coming along. For the moment, you may wish to check out forwardCallbackResult and Processing Moves. That will be improved, but it helps to understand processing moves forward. In particular, see here for an abstraction. That is in the context of the Mover sample game.
From my guess, you're looking for tutorials on implementing that core game logic. Am I on target there?

Thanks got that fixed.
Yes. I've not gotten to doing a Linux version yet. There are a lot of moving parts there and it takes time. It's on my TODO list. (Along with many other things.)
libxayawrap.dll source is compiled from libxayagame is in the libxayagame repository. It needs to be compiled for Linux. The XayaStateProcessor folder is all the DLLs precompiled for Windows. The actual libxayagame DLL is named "libxayawrap.dll" in there. libxayagame currently has no precompiled binaries for Linux.
Regarding the XAYAWrapper.cs file, yes - that is all native Windows calls for kernel32.dll. It won't work in Linux. None of the NativeMethods will work as they're all Windows platform calls.
We have a Mover tutorial that is a console application, but it doesn't accept input. What you can learn there is limited. The XAYA Unity Mover tutorial allows input, but it's C# and Unity, so again, not Linux.
At the moment I've been focusing on C# tutorials. C++ ones will come later.
To make sure that I've answered you:
There are 2 sources. The first is libxayagame and the second is the Windows wrapper here. The first is the actual C++ code and the second is a wrapper for Windows. The wrapper for Windows is still a C++ static library so it needs another wrapper for .NET, which is the XAYAWrapper library.
That may be a bit confusing, so here's a basic diagram:
libxayagame (in C++) >> libxayagame_wrapper (a C++ statically linked library for Windows) >> XAYAWrapper (a C# wrapper for libxayagame_wrapper)
I hope that makes sense for you.
The issue is about platforms. The libxayagame can be used on any platform. However, the other 2 libraries are for C++ on Windows and then C# on Windows.
Hello World currently requires additional work to get it working on Linux.
I hope that helps. If you have additional questions, one of us can answer I'm sure.