roleman.java

恶魔城-晓月圆舞曲 JAVA手機遊戲

				case 1://BACK
					this.changState(LEFT_AIR_BACK_HIT);
					break;
				}
			}
			break;
		case RIGHT_START_DROP:
			drop();//要+if判断
			drawRightStartDrop(g);
			if(hitEnemy() || isEnemyAttRole(g))
			{
				switch(direction)
				{
				case 0://FORE
					this.changState(RIGHT_AIR_HIT);
					break;
				case 1://BACK
					this.changState(RIGHT_AIR_BACK_HIT);
					break;
				}
			}
			break;
		case LEFT_CONTINUANCE_DROP:
			drawLeftDroping(g);
			if(drop())
				changState(RoleMan.LEFT_STAND);
			if(hitEnemy() || isEnemyAttRole(g))
			{
				switch(direction)
				{
				case 0://FORE
					this.changState(LEFT_AIR_HIT);
					break;
				case 1://BACK
					this.changState(LEFT_AIR_BACK_HIT);
					break;
				}
			}
			break;
		case RIGHT_CONTINUANCE_DROP:
			drawRightDroping(g);
			if(drop())
				this.changState(RoleMan.RIGHT_STAND);
			if(hitEnemy() || isEnemyAttRole(g))
			{
				switch(direction)
				{
				case 0://FORE
					this.changState(RIGHT_AIR_HIT);
					break;
				case 1://BACK
					this.changState(RIGHT_AIR_BACK_HIT);
					break;
				}
			}
			break;
		case LEFT_FALL_GROUND://暂时没用到
			drawLeftGroud(g);
			break;
		case RIGHT_FALL_GROUND:
			drawRightGroud(g);
			break;
		case LEFT_GROUND_LIGHTHIT:
			drawLeftLightHit(g);
			break;
		case RIGHT_GROUND_LIGHTHIT:
			drawRightLightHit(g);
			break;
		case LEFT_G_BACK_LIGHTHIT:
			drawBackLeftLightHit(g);
			break;
		case RIGHT_G_BACK_LIGHTHIT:
			drawBackRightLightHit(g);
			break;
		case LEFT_GROUND_BANG:
			break;
		case RIGHT_GROUND_BANG:
			break;
		case LEFT_G_BACK_BANG:
			break;
		case RIGHT_G_BACK_BANG:
			break;
		case LEFT_AIR_HIT:
			drawLeftFlick(g);
			hitFlick();
			break;
		case RIGHT_AIR_HIT:
			drawRightFlick(g);
			hitFlick();
			break;
		case LEFT_AIR_BACK_HIT:
			drawAirBackLeftHit(g);
			hitFlick();
			break;
		case RIGHT_AIR_BACK_HIT:
			drawAirBackRightHit(g);
			hitFlick();
			break;
		case LEFT_COLG_JUMP:
			break;
		case RIGHT_COLG_JUMP:
			break;
		case LEFT_TOP_COLG:
			break;
		case RIGHT_TOP_COLG:
			break;
		case LEFT_AIR_RELEASE:
			setDir(false);
			drawAirLeftReleaseMagic(g);
			switch(lastState)
			{
			case LEFT_ORIGIN_JUMP:
			case LEFT_JUMP:
				if(originJump())
				{
					vY = speedY;
					lastState = LEFT_CONTINUANCE_DROP;
				}
				break;
			case LEFT_START_DROP:
			case LEFT_CONTINUANCE_DROP:
				if(drop())
					changState(RoleMan.LEFT_STAND);
				break;
			}
			relaseMagic();
			break;
		case RIGHT_AIR_RELEASE:
			setDir(true);
			drawAirRightReleaseMagic(g);
			switch(lastState)
			{
			case RIGHT_ORIGIN_JUMP:
			case RIGHT_JUMP:
				if(originJump())
				{
					vY = speedY;
					lastState = RIGHT_CONTINUANCE_DROP;
				}
				break;
			case RIGHT_START_DROP:
			case RIGHT_CONTINUANCE_DROP:
				if(drop())
					changState(RoleMan.RIGHT_STAND);
				break;
			}
			relaseMagic();
			break;
		case LEFT_GROUND_RELEASE:
			drawLeftReleaseMagic(g);
			setDir(false);
			relaseMagic();
			//hitEnemy
			if(hitEnemy() || isEnemyAttRole(g))
			{
				switch(direction)
				{
				case 0://FORE
					this.changState(LEFT_GROUND_LIGHTHIT);
					break;
				case 1://BACK
					this.changState(LEFT_G_BACK_LIGHTHIT);
					break;
				}
			}
			break;
		case RIGHT_GROUND_RELEASE:
			drawRightReleaseMagic(g);
			setDir(true);
			relaseMagic();
			//hitEnemy TODO
			if(hitEnemy() || isEnemyAttRole(g))
			{
				switch(direction)
				{
				case 0://FORE
					this.changState(RIGHT_GROUND_LIGHTHIT);
					break;
				case 1://BACK
					this.changState(RIGHT_G_BACK_LIGHTHIT);
					break;
				}
			}
			break;
		case LEFT_DUCK_BASE:
			break;
		case RIGHT_DUCK_BASE:
			break;
		case LEFT_DOWN_DUCK:
			break;
		case RIGHT_DOWN_DUCK:
			break;
		case LEFT_AIR_DUCK:
			break;
		case RIGHT_AIR_DUCK:
			break;
		case LEFT_CREESE_BASE:
			drawLeftDownPlAtt(g);
			attHitEnemy();
			
			if(hitEnemy())
			{
				changState(LEFT_WENTDOWN_HIT);
			}
			break;
		case RIGHT_CREESE_BASE:
			drawRightDownPlAtt(g);
			attHitEnemy();
		
			if(hitEnemy())
			{
				changState(RIGHT_WENTDOWN_HIT);
			}
			break;
		case LEFT_DOWN_CREESE:
			drawLeftPlAtt(g);
			attHitEnemy();
				
			if(hitEnemy())
			{
				switch(direction)
				{
				case 0://FORE
					this.changState(LEFT_GROUND_LIGHTHIT);
					break;
				case 1://BACK
					this.changState(LEFT_G_BACK_LIGHTHIT);
					break;
				}
			}
			break;
		case RIGHT_DOWN_CREESE:
			drawRihgtPlAtt(g);
			attHitEnemy();
			if(hitEnemy())
			{
				switch(direction)
				{
				case 0://FORE
					this.changState(RIGHT_GROUND_LIGHTHIT);
					break;
				case 1://BACK
					this.changState(RIGHT_G_BACK_LIGHTHIT);
					break;
				}
			}
			break;
		case LEFT_AIR_CREESE:
			drawLeftJumpAtt(g);
			switch(lastState)
			{
			case LEFT_ORIGIN_JUMP:
			case LEFT_JUMP:
				if(originJump())
				{
					vY = speedY;
					lastState = LEFT_CONTINUANCE_DROP;
				}
				break;
			case LEFT_START_DROP:
			case LEFT_CONTINUANCE_DROP:
				if(drop())
					changState(RoleMan.LEFT_STAND);
				break;
			}
			attHitEnemy();
				
			if(hitEnemy())
			{
				switch(direction)
				{
				case 0://FORE
					this.changState(LEFT_AIR_HIT);
					break;
				case 1://BACK
					this.changState(LEFT_AIR_BACK_HIT);
					break;
				}
				initJump();
			}
			break;
		case RIGHT_AIR_CREESE:
			drawRightJumpAtt(g);
			switch(lastState)
			{
			case RIGHT_ORIGIN_JUMP:
			case RIGHT_JUMP:
				if(originJump())
				{
					vY = speedY;
					lastState = RIGHT_CONTINUANCE_DROP;
				}
				break;
			case RIGHT_START_DROP:
			case RIGHT_CONTINUANCE_DROP:
				if(drop())
					changState(RoleMan.RIGHT_STAND);
				break;
			}
			attHitEnemy();
				
			if(hitEnemy())
			{
				switch(direction)
				{
				case 0://FORE
					this.changState(RIGHT_AIR_HIT);
					break;
				case 1://BACK
					this.changState(RIGHT_AIR_BACK_HIT);
					break;
				}
				initJump();
			}
			break;
		case LEFT_DEAD:
			drawLeftDead(g);
			break;
		case RIGHT_DEAD:
			drawRightDead(g);
			break;
		case LEFT_WENT_DOWN:
			drawLeftWentDown(g);
			if(hitEnemy())
			{
				changState(LEFT_WENTDOWN_HIT);
			}
			break;
		case RIGHT_WENT_DOWN:
			drawRightWentDown(g);
			if(hitEnemy())
			{
				changState(RIGHT_WENTDOWN_HIT);
			}
			break;
		case LEFT_LIE_DOWN:
			break;
		case LEFT_DOWN_GROUND:
			drawLeftDownGroud(g);
			break;
		case RIGHT_DOWN_GROUND:
			drawRightDownGroud(g);
			break;
		case LEFT_WENTDOWN_HIT:
			drawLeftBruiseDown(g);
			break;
		case RIGHT_WENTDOWN_HIT:
			drawRightBruiseDown(g);
			break;
	
			
		}
		tickAll(g);
	}
	//paint 结束
	

	private void drawLeftDead(Graphics g)
	{
		if((frame+1)==maxFrame)
		{
			frame = (byte)(maxFrame-1);
			stateSpeed = 0;
 		}
		tickArgmentMirror(dead,(byte)5);
		drawLeftRole(g,roleBase);
	}
	private void drawRightDead(Graphics g)
	{
		if((frame+1)==maxFrame)
		{
			frame = (byte)(maxFrame-1);
			stateSpeed = 0;
 		}
		tickArgment(dead,(byte)5);
		drawRightRole(g,roleBase);
	}
	private void drawAirLeftReleaseMagic(Graphics g)
	{
		tickArgmentMirror(air_relseMagic);
		drawLeftRole(g,roleBase);
	}
	private void drawAirRightReleaseMagic(Graphics g)
	{
		tickArgment(air_relseMagic);
		drawRightRole(g,roleBase);
	}
	private void drawLeftReleaseMagic(Graphics g)
	{
		tickArgmentMirror(relseMagic);
		drawLeftRole(g,roleBase);
	}
	private void drawRightReleaseMagic(Graphics g)
	{
		tickArgment(relseMagic);
		drawRightRole(g,roleBase);
	}
	private void drawLeftBruiseDown(Graphics g)
	{
		tickArgmentMirror(wentDownHit,(byte)3);
		drawLeftRole(g,roleBase);
	}
	private void drawRightBruiseDown(Graphics g)
	{
		tickArgment(wentDownHit,(byte)3);
		drawRightRole(g,roleBase);
	}
	private void drawLeftDownGroud(Graphics g)
	{
		tickArgmentMirror(downGroud);
		drawLeftRole(g,roleBase);
	}
	private void drawRightDownGroud(Graphics g)
	{
		tickArgment(downGroud);
		drawRightRole(g,roleBase);
	}
	private void drawLeftFlick(Graphics g)
	{
		tickArgmentMirror(flick);
		drawLeftRole(g,roleBase);
	}
	private void drawRightFlick(Graphics g)
	{
		tickArgment(flick);
		drawRightRole(g,roleBase);
	}
	private void drawAirBackLeftHit(Graphics g)
	{
		if((frame+1)==maxFrame)
		{
			frame = (byte)(maxFrame-1);
			stateSpeed = 0;
 		}
		tickArgment(air_con_bruise,(byte)3);
		drawRightRole(g,roleBase);
	}
	private void drawAirBackRightHit(Graphics g)
	{
		if((frame+1)==maxFrame)
		{
			frame = (byte)(maxFrame-1);
			stateSpeed = 0;
 		}
		tickArgmentMirror(air_con_bruise,(byte)3);
		drawLeftRole(g,roleBase);
	}
	private void drawBackLeftLightHit(Graphics g)
	{
		tickArgment(con_bruise,(byte)3);
		drawRightRole(g,roleBase);
	}
	private void drawBackRightLightHit(Graphics g)
	{
		tickArgmentMirror(con_bruise,(byte)3);
		drawLeftRole(g,roleBase);
	}
	private void drawLeftLightHit(Graphics g)
	{
		tickArgmentMirror(bruise,(byte)3);
		drawLeftRole(g,roleBase);
	}
	private void drawRightLightHit(Graphics g)
	{
		tickArgment(bruise,(byte)3);
		drawRightRole(g,roleBase);
	}
	private void drawLeftJumpAtt(Graphics g)
	{
		tickArgmentMirror(jumpAtt);
		drawLeftRole(g,attRole);
	}
	private void drawRightJumpAtt(Graphics g)
	{
		tickArgment(jumpAtt);
		drawRightRole(g,attRole);
	}
	private void drawLeftDownPlAtt(Graphics g)
	{
		tickArgmentMirror(downPlAtt);
		drawLeftRole(g,attRole);
	}
	private void drawRightDownPlAtt(Graphics g)
	{
		tickArgment(downPlAtt);
		drawRightRole(g,attRole);
	}
	private void drawLeftJump(Graphics g)
	{
		tickArgmentMirror(jump);
		drawLeftRole(g,roleBase);
	}
	private void drawRihgtJump(Graphics g)
	{
		tickArgment(jump);
		drawRightRole(g,roleBase);
	}
	private void drawLeftOriJump(Graphics g)
	{
		tickArgmentMirror(orgJump);
		drawLeftRole(g,roleBase);
	}
	private void drawRightOriJump(Graphics g)
	{
		tickArgment(orgJump);
		drawRightRole(g,roleBase);
	}
	private void drawLeftStartDrop(Graphics g)
	{
		tickArgmentMirror(startDrop);
		drawLeftRole(g,roleBase);
	}
	private void drawRightStartDrop(Graphics g)
	{
		tickArgment(startDrop);
		drawRightRole(g,roleBase);
	}
	private void drawLeftGroud(Graphics g)//落地？忘了。。。汗
	{
		tickArgmentMirror(group);
		drawLeftRole(g,roleBase);
	}
	private void drawRightGroud(Graphics g)
	{
		tickArgment(group);
		drawRightRole(g,roleBase);
	}
	private void drawLeftDroping(Graphics g)//持续下落
	{
		tickArgmentMirror(droping);
		drawLeftRole(g,roleBase);
	}
	private void drawRightDroping(Graphics g)
	{
		tickArgment(droping);
		drawRightRole(g,roleBase);
	}
	private void drawLeftPlAtt(Graphics g)
	{
		tickArgmentMirror(paAtt,(byte)1);
		drawLeftRole(g,attRole);
	}
	private void drawRihgtPlAtt(Graphics g)
	{
		tickArgment(paAtt,(byte)1);
		drawRightRole(g,attRole);
	}
	private void drawRTOL(Graphics g)
	{
		tickArgment(rToL);
		drawRightRole(g,roleBase);
	}
	private void drawLTOR(Graphics g)
	{
		tickArgmentMirror(rToL);
		drawLeftRole(g,roleBase);
	}
	private void drawRightWentDown(Graphics g)
	{
		if((frame+1)==maxFrame)
		{
			frame = (byte)(maxFrame-1);
			stateSpeed = 0;
 		}
		tickArgment(wentDown);
		drawRightRole(g,roleBase);
	}
	private void drawLeftWentDown(Graphics g)
	{
		if((frame+1)==maxFrame)
		{
			frame = (byte)(maxFrame-1);
			stateSpeed = 0;
 		}
		tickArgmentMirror(wentDown);
		drawLeftRole(g,roleBase);
	}
	private void drawLeftReadyMagic(Graphics g)
	{
		if((frame+1)==maxFrame)
		{
			frame = (byte)(maxFrame-1);
			stateSpeed = 0;
 		}
		tickArgmentMirror(readyMagic);
		drawLeftRole(g,roleBase);
	}
	private void drawRightReadyMagic(Graphics g)
	{
		if((frame+1)==maxFrame)
		{
			frame = (byte)(maxFrame-1);
			stateSpeed = 0;
 		}
		tickArgment(readyMagic);
		drawRightRole(g,roleBase);
	}
	private void drawLeftStand(Graphics g)
	{
		tickArgmentMirror(stand,(byte)4);
		drawLeftRole(g,roleBase);
	}
	private void drawRightStand(Graphics g)
	{
		tickArgment(stand,(byte)4);
		drawRightRole(g,roleBase);
	}
	private void drawLeftWalk(Graphics g)
	{
		tickArgmentMirror(walk);
		drawLeftRole(g,roleBase);
	}
	private void drawRightWalk(Graphics g)
	{
		tickArgment(walk);
		drawRightRole(g,roleBase);
	}
	private void drawLeftStop(Graphics g)//向右走停下
	{
		tickArgmentMirror(stop);
		drawLeftRole(g,roleBase);
	}
	private void drawRightStop(Graphics g)
	{
		tickArgment(stop);
		drawRightRole(g,roleBase);
	}
	public byte getFrame()
	{
		return frame;
	}
	public byte getMaxFrame()
	{
		return maxFrame;
	}
	public byte getMaxFrame(byte state)
	{
		return actionFrame[state];
	}
}