页面比较

module rooch_demo::chat {
     }use std::vector;
     use std::string::{String, utf8};
  struct ChatGroup has store
{     use aptos_std::table::{Self, Table};
  id: u64,  use rooch::state_channel::{Self, StateChannel};
     name:
String,     const SERVER_ALREADY_REGISTERED: u64 = 0;
admins: vector<address>    const CHAT_ACCOUNT_ALREADY_REGISTERED: u64 = 1;
 messages:  Table<u64, Message>, 
     struct Message has server_id: u64,store {
         public_keyid: Stringu64,
         create_timetype: u64u16,
       }  props: SimpleMap<String, String>
       struct ChatSession hascontent: storeString,copy,drop {
         chatpublish_group_idtime: u64,
     }
   state_channel_id: u64 
    } struct ChatGroup has store {
      struct Server has key {
id: u64,
         name: String,
          chatGroupsadmins: vector<ChatGroup>,vector<address>
          chatSessionsmessages: Table<u64, ChatSession>Message>,
          adminsserver_id: vector<address>u64,
          next_chat_group_idpublic_key: u64String,
     }    create_time: u64,
     }
     
     struct ChatAccountChatSession has keystore,copy,drop {
          namechat_group_id: Stringu64,
          groupsstate_channel_id: Table<u64,u64
PrivateKey>,     }
     sessions:
vector<ChatSession>,     struct }Server has key {
        public fun server_register(accountname: &signerString,
name: vector<u8>) {        chatGroups: vector<ChatGroup>,
 let addr = signer::address_of(account);      chatSessions: Table<u64, ChatSession>,
  assert!(!exists<Server>(addr), error::already_exists(SERVER_ALREADY_REGISTERED));       admins: vector<address>,
          next_chat_group_id: u64,
 let server = Server {}
     
     struct name: utf8(name),
 ChatAccount has key {
          chatGroupsname: vector::empty<ChatGroup>()String,
            chatSessionsgroups: table::new<u64Table<u64, ChatSession>()PrivateKey>,
            adminssessions: vector::empty<address>()vector<ChatSession>,
     }
     
next_chat_group_id: 0,
       public fun server_register(account: &signer, name: vector<u8>) {
     };     let addr =   vectorsigner::append<address>(&mut server.admins, addraddress_of(account);
          assert!(!exists<Server>(addr), error::already_exists(SERVER_ALREADY_REGISTERED));
     move_to(account, server);     
  }        let server = Server public{
fun chat_account_register(account: &signer, name: vector<u8>) {       name: utf8(name),
let addr = signer::address_of(account);         assert!(!exists<ChatAccount>(addr), error::already_exists(CHAT_ACCOUNT_ALREADY_REGISTERED));chatGroups: vector::empty<ChatGroup>(),
            chatSessions: table::new<u64, ChatSession>(),
     let chat_account = ChatAccount{    admins: vector::empty<address>(),
       name: utf8(name),    next_chat_group_id: 0,
       groups: table::new<u64, PrivateKey>(), };

           sessions: table::new<u64, ChatSession>(),vector::append<address>(&mut server.admins, addr);
        }; 
        move_to(account, chat_accountserver);
     }
}

module rooch_demo::movecraft {
         x: u128,use std::vector;
          y: u128,
use std::string::{String, utf8};
    } 
     use aptos_std::table::{Self, Table};
  struct Rectangle has store,copy,drop {
use rooch::state_channel::{Self, StateChannel};
     
  top_left: Position,  const SERVER_ALREADY_REGISTERED: u64 = 0;
   bottom_right: Position, const CHAT_ACCOUNT_ALREADY_REGISTERED: u64 =  }1;
     
     struct BlockVector3 has store,copy,drop {
         idx: u64u128,
         typey: u16u128,
         propsz: SimpleMap<String, String>,
   u128,
     create_time: u64
     }
     
     struct LandPosition has store,copy,drop {
         idx: u64u128,
         namey: Stringu128,
     }
   boundary: vector<Rectangle> 
     struct Rectangle  messages: Table<u64, Message>,has store,copy,drop {
         worldtop_addressleft: addressPosition,
         owner: address,
         create_time: u64bottom_right: Position,
     }
     
     struct LandSessionBlock has store,copy,drop {
         world_addressid: addressu64,
         land_idtype: u64u16,
         channel_idprops: u64SimpleMap<String, String>,
         create_time: u64,
     }
     
     struct WorldLand has keystore {
          nameid: Stringu64,
          typename: u8String,
          seedboundary: u128,vector<Rectangle>
          blocksmessages: Table<Vector3Table<u64, Block>Message>,
          landsworld_address: Table<u64, Land>address,
          sessionsowner: vector<LandSession>address,
          next_chat_group_idcreate_time: u64,
     }
     
     struct GameAccountInventory has keystore {
          nameblocks: StringSimpleMap<u16, vector<Block>>,
     }
   sessions: vector<LandSession>, 
    } struct LandSession has store,copy,drop {
       public fun world_register(accountaddress: &signeraddress,
name: vector<u8>) {       land_id: u64,
   let addr = signer::address_of(account);   channel_id: u64,
      assert!(!exists<Server>(addr), error::already_exists(SERVER_ALREADY_REGISTERED));   create_time: u64,
     }
     
     letstruct serverWorld =has Serverkey {
            name: utf8(name)String,
            chatGroupstype: vector::empty<ChatGroup>()u8,
            chatSessionsseed: table::new<u64u128,
ChatSession>(),             adminsblocks: vector::empty<address>()Table<Vector3, Block>,
           next_lands: Table<u64, Land>,
          sessions: vector<LandSession>,
          next_chat_group_id: 0u64,
     }
  };   
     struct  vector::append<address>(&mut server.admins, addr);GameAccount has key {
          name: String,
           move_to(accountsessions: vector<LandSession>,
server);      }
     
     public fun game_accountworld_register(account: &signer, name: vector<u8>) {
          let addr = signer::address_of(account);
          assert!(!exists<ChatAccount>exists<Server>(addr), error::already_exists(CHATSERVER_ACCOUNT_ALREADY_REGISTERED));
          
          let chat_accountserver = Server ChatAccount{
            name: utf8(name),
            groupschatGroups: tablevector::new<u64, PrivateKey>empty<ChatGroup>(),
            sessionschatSessions: table::new<u64, ChatSession>(),
            admins: vector::empty<address>(),
            next_chat_group_id: 0,
        };

        move_to(account, chat_accountvector::append<address>(&mut server.admins, addr);
     }
}