DP-Match

Match system

How to use the DP to be paired for the client.

Step 1

Establish a "dynamic" scene.

DP program (Visual C #)

Result

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

using System.Collections; 
using System.Collections.Generic;


namespace DP_Sample
{
    public partial class DP_003 : Form
    {
        /*****************************************************
        *	Copyright © 2013 arcalet. All Rights Reserved
	    *
	    ******************************************************/

        public ArcaletGame ag = null;
        public string dp_user = ""; //insert super user account here
        public string dp_password = ""; //insert super user password here
        public int onlinePlayerNumber = 0;

        private const string gguid = "";
        private const string sguid = "";
        private const string sguid_game = "";
        byte[] certificate = {};

        List<MatchModel> prList = new List<MatchModel>(); //a list of waiting for match
        List<ArcaletScene> roomList = new List<ArcaletScene>(); //a list of game room

        public DP_003()
        {
            InitializeComponent();
        }

        private void DP_003_Load(object sender, EventArgs e)
        {
            ag = new ArcaletGame(dp_user, dp_password, gguid, sguid, certificate);
            ag.onStateChanged += OnStateChanged;
            ag.onMessageIn += MainMessageIn;
            ag.onPrivateMessageIn += PrivateMessageIn;
            ag.onCompletion += CB_Login;
            ag.Launch();
            label1_look.Text = "On Login";
        }       

        void CB_Login(int code, ArcaletGame game)
        {
            if (code == 0)
                label1_look.Text = "Login Successed";
            else
                label1_look.Text = "Login Failed，Error Code：" + code;
        }

        void OnStateChanged(int state, int code, ArcaletGame game)
        {
            //datectint the state of connection
            if (state >= 900) 
                label1_look.Text = "Disconnection，State：" + state + " Error Code：" + code;
        }

        void MainMessageIn(string msg, int delay, ArcaletGame game)
        {
            try {
                string[] cmds = msg.Split(':'); //split the message and convert to string[]
                switch (cmds[0]) {
                    case "new": PlayerLogin(cmds[1]); break;
                    case "quit": PlayerLogout(cmds[1]); break;
                }
            }
            catch(Exception){ }
        }

        void PlayerLogin(string msg) 
        {
            int poid = int.Parse(msg); //get player's poid from the message
            ag.PrivacySend("dp_new:" + ag.poid, poid); //send back dp's poid to player
            onlinePlayerNumber++; //update online players
            label2_look.Text = onlinePlayerNumber.ToString();
        }

        void PlayerLogout(string msg)
        {            
            lock (prList) {
                int poid = int.Parse(msg);
                foreach (MatchModel modle in prList) {
                    if( modle.poid == poid) prList.Remove(modle); //remove the logout player from prList
                    break;
                }

                label4_look.Text = prList.Count.ToString();
                onlinePlayerNumber--; //update online players
                label2_look.Text = onlinePlayerNumber.ToString();
            }           
        }
        
        void PrivateMessageIn(string msg, int delay, ArcaletGame game)
        {
            try {
                string[] cmds = msg.Split(':'); //split the message and convert to string[]
                switch (cmds[0]) {
                    case "match": PlayerMatch(cmds[1]); break; 
                }
            }
            catch (Exception) { }
        }               
               
        void PlayerMatch(string cmd)
        {
            MatchModel newPlayer = new MatchModel();
            newPlayer.poid = int.Parse(cmd);

            //avoiding exception by using locking prList
            lock (prList) {            
                if (prList.Count == 0) {
                    prList.Add(newPlayer);
                }
                else {
                    foreach (MatchModel modle in prList)                   {
                        MatchModel[] go = new MatchModel[] { newPlayer, modle };
                        StartMatch(go);
                        prList.Remove(modle);
                        break;
                    }
                }
                label4_look.Text = prList.Count.ToString();//update the number of prList
            }
        }

        void StartMatch(MatchModel[] matchInfo)
        {
            //enter an arcalet scene and get the scene sid
            ArcaletScene sn = new ArcaletScene(ag, sguid_game);            
            sn.onMessageIn += GameRoomMessageIn;
            sn.onCompletion += CB_EnterGameRoom;

            GameRoom room = new GameRoom();
            room.modle = matchInfo;
            sn.token = room;

            sn.Launch();
        }

        void CB_EnterGameRoom(int code, ArcaletScene scene)
        {
            if (code == 0) {
                Console.WriteLine("Create Game Room Successed, Scene Sid - " + scene.sid);
                GameRoom room = scene.token as GameRoom;

                //send the sid to players
                ag.PrivacySend("dp_room:" + scene.sid, room.modle[0].poid); 
                ag.PrivacySend("dp_room:" + scene.sid, room.modle[1].poid); 

                roomList.Add(scene); //add to roomList
                label3_look.Text = roomList.Count.ToString();//update rommList count
            }
            else Console.WriteLine("Create Game Room Failed - " + code);
        }
        
        void GameRoomMessageIn(string msg, int delay, ArcaletScene scene)
        {
            try {
                string[] cmds = msg.Split(':'); //split the message and convert to string[]
                switch (cmds[0]) {
                    case "ready": Game_Ready(scene); break;                    
                }
            }
            catch (Exception) { }
        }

        void Game_Ready(ArcaletScene scene)
        {
            Console.WriteLine("Game_Ready");
            GameRoom room = scene.token as GameRoom;
            room.enterPlayersNum++;
            if (room.enterPlayersNum >= 2) scene.Send("dp_start");
        }
    }
}

//define a match model
internal class MatchModel
{ 
    internal int poid = 0;
}

//define a token of arcalet scene
internal class GameRoom
{
    internal MatchModel[] modle = null;
    internal int enterPlayersNum = 0;
}

Client program (Unity3D)

Result

using UnityEngine;
using System.Collections;

public class DP_Match : MonoBehaviour {
	
	/*******************************************************************
	*	Copyright © 2013 arcalet. All Rights Reserved
	*	 
	*******************************************************************/
	
	#region Variables	
	private const string gguid = "";
	private const string sguid = "";
	private const string sguid_game = ""; 
	byte[] certificate = {};
    
	ArcaletGame ag = null;
	ArcaletScene sn = null;
	#endregion	
	
	#region Properties
	void Start()
	{
		ArcaletSystem.UnityEnvironment();
	}
	
	void OnApplicationQuit()
	{
		if(ag!=null) ag.Dispose();		
	}
		
	/*******************************************************************
	*	Start ArcaletGame
	*******************************************************************/
	void ArcaletLaunch( string username, string password)
	{
		if(ag!=null) LogOut();
		errorMsg = "";
		errorMsg2 = "";
		preLogin = true;
		ag = new ArcaletGame(username, password, gguid, sguid, certificate );
		ag.onPrivateMessageIn += PrivateMessageIn;
		ag.onCompletion += CB_ArcaletLaunch;
		ag.STALaunch();
	}
	
	/*******************************************************************
	*	The callback function will receive the completion message after 
	*	launching an ArcaletGame.
	*	code has a value of 0 if the setup succeeded. 
    *  	code value other than 0 means the setup failed.
	*******************************************************************/
	void CB_ArcaletLaunch(int code, ArcaletGame game)
	{
		if(code==0) {			
			onLogin = true;
			preDP_Link = true;
			ag.SendOnClose("quit:" + ag.poid);
			ag.Send("new:" + ag.poid);
		}
		else {
			errorMsg = "\r\nLogin Failed - Code:" + code;
		}
	}

	void PrivateMessageIn(string msg, int delay, ArcaletGame game)
	{
		string[] cmds = msg.Split(':');
		switch(cmds[0]) {			
			case "dp_new": DP_Linked(cmds[1]); break;
			case "dp_room": DP_EnterRoom(cmds[1]); break;
		}
	}

	void DP_Linked(string cmd)
	{
		dp_poid = int.Parse(cmd);
		onDP_Link = true;
	}

	void LogOut()
	{
		if(ag==null) return;		
		ag.Dispose();
		ag = null;
		sid = 0;
		preLogin = false;
		onLogin = false;
		preDP_Link = false;
		onDP_Link = false;
		waitMatch = false;
		enterScene = false;
		prePareGame = false;
		gameStart = false;
	}

	void DP_EnterRoom(string cmd)
	{	
		enterScene = true;
		sid = int.Parse(cmd);
		sn = new ArcaletScene(ag, sguid_game, sid);
		sn.onMessageIn += SceneMessageIn;
		sn.onCompletion += CB_EnterRoom;
		sn.Launch();
	}

	void CB_EnterRoom(int code, ArcaletScene scene)
	{
		if(code==0) {
			prePareGame = true;
			sn.Send("ready");
		}
		else {
			errorMsg2 = "\r\nEnterScene Failed: " + code;
		}
		
	}

	void SceneMessageIn(string msg, int delay, ArcaletScene scene)
	{
		string[] cmds = msg.Split(':');
		switch(cmds[0]) {
			case "dp_start": gameStart = true; break;
		}
	}
	#endregion	
	
	/*******************************************************************
	//	Login UI
	*******************************************************************/
	public Texture2D tick = null;
	string str_acc = "" ;
	string str_pw = "";	

	int dp_poid = 0;
	bool preLogin = false;
	bool onLogin = false;
	bool preDP_Link = false;
	bool onDP_Link = false;	
	string str_state = "On Login...\r\nLogin Successed...\r\nOn DP-Link...\r\nDP-Linked\r\n";

	int sid = 0;
	bool waitMatch = false;
	bool enterScene = false;
	bool prePareGame = false;
	bool gameStart = false;
	string matchState = "Waiting for Match...\r\nEnter Game Scene...\r\nPreparing the Game...\r\nGame Start\r\n";
	string errorMsg = "";
	string errorMsg2 = "";
	
	void OnGUI()
	{			
		GUI.Box( new Rect(200, 150, 600, 150), "");
		GUI.Box( new Rect(200, 300, 600, 200), "");
		GUI.Label(new Rect( 250,200,100,30), "Account");
		GUI.Label(new Rect( 250,250,100,30), "Password");
		
		str_acc = GUI.TextField(new Rect(320, 200, 250, 30), str_acc, 10);
		str_pw = GUI.PasswordField(new Rect(320, 250, 250, 30), str_pw, "*"[0], 20);		

		if(preLogin) GUI.DrawTexture(new Rect(630, 205, 10, 10), tick);
		if(onLogin) GUI.DrawTexture(new Rect(630, 220, 10, 10), tick);
		if(preDP_Link) GUI.DrawTexture(new Rect(630, 235, 10, 10), tick);
		if(onDP_Link) GUI.DrawTexture(new Rect(630, 250, 10, 10), tick);

		if(onDP_Link) 
		{
			GUI.Label(new Rect( 650,200,400,100), str_state + "DP_Poid: " + dp_poid);

			if(waitMatch) {
				if( GUI.Button(new Rect(200, 300, 600, 50), "Logout")) LogOut();
			}
			else 
			{
				if( GUI.Button(new Rect(200, 300, 300, 50), "Start Match")) 
				{
					waitMatch = true;
					ag.PrivacySend("match:" + ag.poid, dp_poid);
				}
				if( GUI.Button(new Rect(500, 300, 300, 50), "Logout")) LogOut();
			}
		}
		else 
		{
			GUI.Label(new Rect( 650,200,400,100), str_state + errorMsg);
			if( GUI.Button(new Rect(200, 300, 600, 50), "Login"))
				ArcaletLaunch(str_acc, str_pw);			
		}
		
		GUI.Label(new Rect( 250,370,500,180), matchState + errorMsg2);
		if(waitMatch) GUI.DrawTexture(new Rect(220, 375, 10, 10), tick);
		if(enterScene) GUI.DrawTexture(new Rect(220, 390, 10, 10), tick);
		if(prePareGame) GUI.DrawTexture(new Rect(220, 405, 10, 10), tick);
		if(gameStart) GUI.DrawTexture(new Rect(220, 420, 10, 10), tick);
	}
}

Download

Was this page helpful?

Yes No