Monster Card Game的设计与实现之服务器篇

服务器端大概有这么几个类:

MonsterCard类:定义卡牌的属性

Deck类:用来生产一堆卡牌,在这个游戏中共40张怪兽卡牌。

Player类:用来定义一个玩家,这个玩家具有40张怪兽卡牌和8000滴血,然后根据玩家的对战情况进行减少卡牌或扣除学的操作。

MyServerReader类:建立一个线程,根据对方玩家发来的的命令来对自己或对方玩家的怪兽卡牌进行操作

MyServerWriter类:建立一个线程,根据自己发出的的命令来对自己或对方玩家的怪兽卡牌进行操作

ServerTest类:负责和客户端进行通信,共享玩家的数据。

MonsterCard类

//定义卡牌的属性

package game;

import java.util.Random;

public class MonsterCard {
	public static Random random=new Random();
	private String MonsterName;
	private int attactPower;
	private int defencePower;
	public MonsterCard(String name,int attack,int defence) {
		// TODO Auto-generated constructor stub
		MonsterName=name;
		attactPower=attack;
		defencePower=defence;
	}

	public int getAttackPower()
	{
		return attactPower;
	}
	public int getDefencePower()
	{
		return defencePower;
	}
	public String getName()
	{
		return MonsterName;
	}
}

Deck类

//用来生产一堆卡牌,在这个游戏中共40张怪兽卡牌。

package game;
import java.util.LinkedList;

//**************************class Deck***************************
public class Deck {
	private LinkedList<MonsterCard>list=new LinkedList<MonsterCard>();
	private static int n=40;
	private int count;
	String []monsterName={"bear","tiger","dragan","lion","elephent","dog","cat","dophin"};
	int len=monsterName.length-1;
	public Deck()
	{
		count=n;
		int attackPower=0;
		int defencePower=0;
		for(int i=0;i<n;i++)
		{
			String name=monsterName[MonsterCard.random.nextInt(len)];
			attackPower=MonsterCard.random.nextInt(2500);
			defencePower=MonsterCard.random.nextInt(2000);
			list.addLast(new MonsterCard(name, attackPower, defencePower));
		}
	}
	//由Deck中取牌
	public  MonsterCard GetCard()
	{
		int num=MonsterCard.random.nextInt(count);
		MonsterCard temp=list.get(num);
		list.remove(num);
		count--;
		return temp;
	}

}

Player类

//用来定义一个玩家,这个玩家具有40张怪兽卡牌和8000滴血,然后根据玩家的对战情况进行减少卡牌或扣除学的操作。

package game;

import java.util.Iterator;
import java.util.LinkedList;
//*********************class Player***************************
public class Player
{
	private boolean isOk;//标识是否可以对战场上的牌进行操作
	private int term=1;//记录第几局
	private  int blood=8000;
	private Deck deck=new Deck();
	private LinkedList<MonsterCard>cardInHand=new LinkedList<MonsterCard>();
	private LinkedList<MonsterCard>cardInFiled=new LinkedList<MonsterCard>();
	private int count=0;
	//初始化手中的牌
	public Player(){
		getCard();
	}
	//是否被打败
	public boolean beDefeated()
	{
		if(blood<=0||(count>=40&&cardInFiled.isEmpty()&&cardInHand.isEmpty()))
			return true;
		else
			return false;
	}
	//杀死战场的怪兽
	public void killMonster(int n)
	{
		cardInFiled.remove(n-1);
	}
	//改变血量
	public void changeBlood(int n)
	{
		blood-=n;
	}
	//获得血量
	public int getBlood()
	{
		return blood;
	}
	//changeTerm
	public void changeTerm()
	{
		++term;
	}
	//get Term
	public int getTerm()
	{
		return term;
	}
	//获得手上的牌
	public LinkedList<MonsterCard>getCardInHand()
	{
		return cardInHand;
	}
	//获得战场上的牌
	public LinkedList<MonsterCard>getCardInField()
	{
		return cardInFiled;
	}
	//标识是否可以对战场上的牌进行操作
	public boolean isNotOk()
	{
		if(count>1)
			isOk=true;
		else {
			isOk=false;
		}
		return isOk;
	}
	//从deck堆中获得牌
	public void getCard()
	{
		cardInHand.addLast(deck.GetCard());
		count++;
		isNotOk();//用来标识是否可对自己战场上的牌进行操作
	}
	//显示牌
	public String showCard(LinkedList<MonsterCard>list)
	{
		StringBuffer sBuffer=new StringBuffer();
		Iterator<MonsterCard>iterator=list.listIterator();
		MonsterCard monster=null;
		while(iterator.hasNext())
		{
			monster=(MonsterCard)iterator.next();
			sBuffer.append("名字:"+monster.getName());
			sBuffer.append(" 攻击力:"+monster.getAttackPower());
			sBuffer.append("防御力:"+monster.getDefencePower());
			sBuffer.append("\n");
		}
		return sBuffer.toString();
	}
	//显示手中的牌
	public String showMyHand()
	{
		return showCard(cardInHand);
	}
	//显示手中的牌
	public String showMyBf()
	{
		return showCard(cardInFiled);
	}
	//召唤手中的牌到战场上
	public void SummonMonster(int n)
	{
		if(count==0)
			System.out.println("Player1 has been defeated!");
		MonsterCard monsterCard=cardInHand.get(n-1);
		cardInFiled.addLast(monsterCard);
		cardInHand.remove(n-1);
		count--;
	}
	//选择自己的怪兽
	public MonsterCard chooseMyMonster(int n)
	{
		return cardInFiled.get(n-1);
	}

}

MyServerReader类

//建立一个线程,根据对方玩家发来的的命令来对自己或对方玩家的怪兽卡牌进行操作

package game;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

//创建一个进程用来进行接收读取数据
public class MyServerReader extends ServerTest3 implements Runnable{
    private DataInputStream dis;
    private DataOutputStream dos;
    public MyServerReader (DataInputStream dis,DataOutputStream dos){
        this.dis = dis;
        this.dos=dos;
    }
    public void run(){
        String msg;
        String string=null;
        int lenSummon="Summon monster".length();
        int lenChoose="choose my card".length();
        int lenAttack="attack".length();
        int num=0;
        MonsterCard monsterCard=null;
        try{
            while(true){
            	num=0;
            	string=null;
            	monsterCard=null;
                msg = dis.readUTF().trim();
                if(msg.equals("end the term"))
                {
                	player1.changeTerm();
                	dos.writeUTF("wait...");
                	player1.getCard();
                	System.out.println("Term "+player1.getTerm()+":");
                	continue;
                }else if(msg.equals("show my hand"))
                {
                	string=player2.showMyHand();
                	dos.writeUTF(string);
                	continue;
                	//System.out.println(string);
                }else if (msg.equals("show my bf")) {
                	string=player2.showMyBf();
                	dos.writeUTF(string);
                	continue;
				}else if(msg.equals("show op bf"))
				{
					string = player1.showMyBf();
					dos.writeUTF(string);
					continue;
				}else if(msg.startsWith("summon monster"))
				{
					System.out.println("Summon monster start...");
					player2.SummonMonster(Integer.parseInt(msg.substring(lenSummon).trim()));
                	continue;
				}else if(msg.startsWith("choose my card"))
				{
					if(player2.isNotOk())
                	{
                		num=Integer.parseInt(msg.substring(lenChoose).trim());//自己手上的第几个怪兽
                		monsterCard=player2.chooseMyMonster(num);
                		msg = dis.readUTF().trim();
                        if(msg.startsWith("attack"))
                        {
                        	int opNum=Integer.parseInt(msg.substring(lenAttack).trim());
                        	MonsterCard opMonsterCard=player1.chooseMyMonster(opNum);
                        	int attackPower=monsterCard.getAttackPower();
                        	int defencePower=opMonsterCard.getDefencePower();
                        	if(attackPower>defencePower)
                        	{
                        		player1.changeBlood(attackPower-defencePower);
                        		player1.killMonster(opNum);
                        	}else if(attackPower<defencePower)
                        	{
                        		player2.killMonster(num);
                        	}else {
                        		player2.killMonster(opNum);
                        		player1.killMonster(num);
							}
                        	if(player1.beDefeated())
                        	{
                        		System.out.println("You have been defeated!");
                        		dos.writeUTF("Congratulations!You are the winner.");
                        	}else if(player2.beDefeated())
                        	{
                        		System.out.println("Congratulations!You are the winner.");
                        		dos.writeUTF("You have been defeated!");
                        	}
                        }

                	}
					continue;
				}else if(msg.equals("show my blood")){
					String str ="the current blood is:"+player2.getBlood();
					dos.writeUTF(str);
				}
				else if(msg.equals("bye")){
                    System.out.println("对方下线,程序退出");
                    System.exit(0);
                }else {
                	System.out.println("Client:" + msg);
				}

            }
        }catch(IOException e){
            System.out.println(e);
        }
    }
}  

MyServerWriter类

//建立一个线程,根据自己发出的的命令来对自己或对方玩家的怪兽卡牌进行操作

package game;

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;

//创建一个进程用来写入并发送数据
public class MyServerWriter extends ServerTest3 implements Runnable{
    private DataOutputStream dos;
    public MyServerWriter(DataOutputStream dos){
        this.dos = dos;
    }
    public void run(){
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        String msg;
        String str=null;
        int len=0;
        int lenSummon="Summon monster".length();
        int lenChoose="choose my card".length();
        int lenAttack="attack".length();
        MonsterCard monsterCard=null;
        int num=0;
        try{
            while(true){
            	str=null;
            	msg=null;
            	monsterCard=null;
                msg = br.readLine();
                str=msg.trim();
                len=str.length();
                if(str.equals("show my hand"))
                {
                	str=player1.showMyHand();
                	System.out.println(str);
                	continue;
                }
                else if(str.equals("show my bf"))
                {
                	str=player1.showMyBf();
                	System.out.println(str);
                	continue;
                }
                else if(str.equals("show op bf"))
                {
                	str=player2.showMyBf();
                	System.out.println(str);
                	continue;
                }
                else if(str.equals("end the term"))
                {
                	player2.changeTerm();//回合结束,修改自己的回合数
                	System.out.println("wait...");
                	player2.getCard();//启动另一个回合
                	dos.writeUTF("Term "+player2.getTerm()+":");
                	continue;
                }
                else if(str.startsWith("summon monster"))
                {
                	System.out.println("Summon monster start...");
                	player1.SummonMonster(Integer.parseInt(str.substring(lenSummon).trim()));
                	continue;
                }
                else if(str.startsWith("choose my card"))
                {
                	if(player1.isNotOk())
                	{
                		num=Integer.parseInt(str.substring(lenChoose).trim());//自己手上的第几个怪兽
                		monsterCard=player1.chooseMyMonster(num);
                		msg = br.readLine();
                		str=msg.trim();
                        len=str.length();
                        if(str.startsWith("attack"))
                        {
                        	int opNum=Integer.parseInt(str.substring(lenAttack).trim());
                        	MonsterCard opMonsterCard=player2.chooseMyMonster(opNum);
                        	int attackPower=monsterCard.getAttackPower();
                        	int defencePower=opMonsterCard.getDefencePower();
                        	if(attackPower>defencePower)
                        	{
                        		player2.changeBlood(attackPower-defencePower);
                        		player2.killMonster(opNum);
                        	}else if(attackPower<defencePower)
                        	{
                        		player1.killMonster(num);
                        	}else {
                        		player2.killMonster(opNum);
                        		player1.killMonster(num);
							}
                        	if(player1.beDefeated())
                        	{
                        		System.out.println("You have been defeated!");
                        		dos.writeUTF("Congratulations!You are the winner.");
                        	}else if(player2.beDefeated())
                        	{
                        		System.out.println("Congratulations!You are the winner.");
                        		dos.writeUTF("You have been defeated!");
                        	}

                        }
                        continue;
                	}

                }else if(msg.equals("show my blood")){
					System.out.println("the current blood is:"+player1.getBlood());
					continue;
				}

                else if(msg.equals("bye")){
                    System.out.println("自己下线,程序退出");
                    System.exit(0);
                }else {
                	dos.writeUTF("Server:"+msg);
				}
            }
            }catch(IOException e){
            	e.printStackTrace();
        }
    }
} 

ServerTest类

//负责和客户端进行通信,共享玩家的数据。

package game;

import java.io.*;
import java.net.*;  

public class ServerTest3{
	protected  static Player player1=new Player();//创建玩家<span id="_xhe_cursor"></span>1,子类共享基类的变量
	protected  static Player player2=new Player();//创建玩家2
	ServerTest3 server=null;
	private  MonsterCard monsterOp=null;
	public  MonsterCard getMonsterCard(){
		return monsterOp;
	}
	public void  SetMonsterCard(MonsterCard monster)
	{
		this.monsterOp=monster;
	}
	public static void main(String[] args){
		ServerTest3 server =new ServerTest3();//创建连接实例
		server.connectToClient();//通信函数
    }
	public void connectToClient()
	{
		DataOutputStream serverDos =null;
		DataOutputStream serverDos1 =null;
		DataInputStream serverDis =null;
		try{
            //设置sever端的链接
            ServerSocket s = new ServerSocket(10004);
            Socket s1 =null;
            try {
            	s1 = s.accept();//sever等待链接
                System.out.println("Link in succeed...");
                System.out.println("Term 1:");
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
            //实例化输出流
            OutputStream os = s1.getOutputStream();
            serverDos= new DataOutputStream(os);
            OutputStream os1 = s1.getOutputStream();
            serverDos1= new DataOutputStream(os1);
            //实例化输入流
            InputStream is = s1.getInputStream();
            serverDis= new DataInputStream(is);
            //实例化两个线程的对象
            MyServerReader msr = new MyServerReader(serverDis,serverDos1);
            MyServerWriter msw = new MyServerWriter(serverDos);
            //启动线程
            new Thread(msr).start();
            new Thread(msw).start();
        }
        //捕获异常
        catch(SocketException e){
            System.out.println(e);
        }catch(IOException e){
            System.out.println(e);
        }
	}
}
时间: 12-09

Monster Card Game的设计与实现之服务器篇的相关文章

Monster Card Game的设计与实现之框架篇

事实上,Monster Card Game并没有完全实现,或者说并没有完全实现需求分析要求所实现的功能.即使是那些实现的部分,看过一个本科生写的关于Java SE的专栏后,还是感觉自己的程序弱爆了,简直可以称得上是漏洞百出.革命尚未成功,程序仍有待完善啊^-^.但谁又能说这不是一个进步的过程呢?看那些蹒跚学步的小孩,谁又能想到日后的破坏力呢.所以,好的开始总是值得窃喜的,哈哈哈... 由于需求不是很明确,再加上时间比较急,所以还没有好好设计好就开始写程序,所以,免不了一次又一次的修改,推倒重来.

Monster Card Game的设计与实现之客户端篇

客户端 ClientTest类:负责和服务器进行通信,建立两个线程,分别发送和接收客户端发出的命令和接收服务器端发出的命令. ClientTest3.java package game; import java.io.*; import java.net.*; public class ClientTest3{ public static void main(String[] args){ try{ //链接sever端 Socket s1 = new Socket("127.0.0.1&quo

《新浪微博自动评论软件&#183;设计与实现之UI篇》

任务:编写用户界面 使用Python中的wxPython对界面进行编写工作 预计的按钮有:登录,评论,退出 预计的输入框有:cookie.评论内容.搜索关键字 预计的单选框有:是否使用关键字搜索 首先,看看我们需要的控件都有哪些,按钮(Button).单选按钮(RadioButton).静态文本(StaticText).可编辑文本(TextCtrl),到WxPythonInAction查看对应的文档,要注意到的是,wxPython和之前玩的MFC不一样,不是先设计界面,再编写代码,而是所有控件的

MMORPG大型游戏设计与开发(服务器 AI 概述)

游戏世界中我们拥有许多对象,常见的就是角色自身以及怪物和NPC,我们可以见到怪物和NPC拥有许多的行为,比如说怪物常常见到敌对的玩家就会攻击一样,又如一些NPC来游戏世界中走来走去,又有些怪物和NPC有的时候还会发出一些奇怪的谈论.我们都知道物体是死的,没有生命的,程序其实就是一种物体,它本身是不会进行任何的操作的,比如场景中的角色我们不操作则傻站着一样.但是NPC和怪物似乎有自己的判断力,谁该打谁不该打,还会排队行走,这些不是有生命的才能实现的吗?这就是AI,全称为Actificial Int

MMORPG大型游戏设计与开发(服务器 游戏场景 搜索机)

双十一注定是忙碌的日子,所以到了现在我才将今天自己学习的内容拿出来跟大家分享.搜索机是我自己暂时取的名字,其实简单的说就是场景里提供搜索的一个工具,负责场景对象的范围搜索和获取.空洞的理论总是让人一头雾水,如果玩过游戏的朋友不妨想一想查看附近的玩家.选择附近的玩家.点击任务怪物名称就可以自动寻路打怪这些功能就大致有个印象了. 一张截图 搜索机 1.数据 1. 状态 typedef enum operator_status_enum { kOperatorStatusContinue, //扫描继

ThreadLocal的设计与使用(原理篇)

在jdk1.2推出时开始支持java.lang.ThreadLocal.在J2SE5.0中的声明为: public class ThreadLocal<T> extends Object ThreadLocal是什么呢?其实ThreadLocal并非是一个线程的本地实现版本,它并不是一个Thread,而是thread local variable(线程局部变量).也许把它命名为ThreadLocalVar更加合适.线程局部变量(ThreadLocal)其实的功用非常简单,就是为每一个使用该变量

MMORPG大型游戏设计与开发(服务器 游戏场景 地图和区域)

地图的数据以及区域的信息是场景的重要组成部分,这些数据同时存在客户端和服务器,而且都是由编辑器生成的.那么保存的文件数据结构是怎样的?一张3D的场景地图又是怎样处理这些数据的?同时告诉大家这里同样只是讲的理论与设计,理论和设计往往都很空洞,但是却很灵活,需要靠每个人怎么运用. 一些图片 区域和格子 从上面的截图可以看出游戏场景其实是由格子来区分的,不管是矩形的格子还是其他形状的格子也好,一张地图不可能只有一个点(即多点组成一张地图).在3D场景中似乎格子的位置总伴随着高度信息,所以让人感觉有些迷

MMORPG大型游戏设计与开发(服务器 AI 逻辑设定和状态结点)

人工智能(AI)中往往都会有这么一个问题,那就是我要做什么?我该怎么做?我需要什么?所以这里所谓的智能就是赋予AI对象的判断力,以及它根据判断得到的相应反应.就好比,你去商店买东西,钱够别人才卖给你,不够不可能卖你,这里就会触发了两种结果,如果你要强买的话,那么店员就可能产生相应的措施了.其实这里的店员,就相当于我们所谓的人工智能,不过店员的反应和动作是根据他自身思考产生的,人工智能也有这个思考的过程,只不过比店员想的少很多.这个思考的过程,也就是逻辑设定与处理的过程,那么什么又是状态结点呢?

数独游戏的设计与实现之第一篇——理解数独过程

数独是一种运用纸.笔进行演算的逻辑游戏.玩家需要根据9×9盘面上的已知数字,推理出所有剩余空格的数字,并满足每一行.每一列.每一个粗线宫内的数字均含1-9,不重复. 摒除法,数独盘面是个九宫,每一宫又分为九个小格.在这八十一格中给出一定的已知数字和解题条件,利用逻辑和推理,在其他的空格上填入1-9的数字.使1-9每个数字在每一行.每一列和每一宫中都只出现一次,所以又称“九宫格”.基本解题方法:摒除法,余数法,直观法,候选数法(参考百度百科)