Java学习者论坛

 找回密码
 立即注册

QQ登录

只需一步,快速开始

手机号码,快捷登录

恭喜Java学习者论坛(https://www.javaxxz.com)已经为数万Java学习者服务超过8年了!积累会员资料超过10000G+
成为本站VIP会员,下载本站10000G+会员资源,购买链接:点击进入购买VIP会员
JAVA高级面试进阶视频教程Java架构师系统进阶VIP课程

分布式高可用全栈开发微服务教程

Go语言视频零基础入门到精通

Java架构师3期(课件+源码)

Java开发全终端实战租房项目视频教程

SpringBoot2.X入门到高级使用教程

大数据培训第六期全套视频教程

深度学习(CNN RNN GAN)算法原理

Java亿级流量电商系统视频教程

互联网架构师视频教程

年薪50万Spark2.0从入门到精通

年薪50万!人工智能学习路线教程

年薪50万!大数据从入门到精通学习路线年薪50万!机器学习入门到精通视频教程
仿小米商城类app和小程序视频教程深度学习数据分析基础到实战最新黑马javaEE2.1就业课程从 0到JVM实战高手教程 MySQL入门到精通教程
查看: 222|回复: 0

[J2ME学习]RPG游戏示例代码

[复制链接]
  • TA的每日心情
    开心
    2021-3-12 23:18
  • 签到天数: 2 天

    [LV.1]初来乍到

    发表于 2014-10-11 04:01:26 | 显示全部楼层 |阅读模式

      
      
      RPG游戏示例代码,基于MIDP1.0技术实现。
    1. import javax.microedition.lcdui.*;
    2. /**
    3. * RPG游戏示例代码 实现了按键的连续移动
    4. */
    5. public class RPGCanvas extends Canvas implements Runnable {
    6.         /** 游戏状态 */
    7.         private int status;
    8.         // 游戏状态设定
    9.         /** 村庄1 */
    10.         private final static int SCREEN_1 = 0;
    11.         /** 武器店 */
    12.         private final static int WEAPON_SHOP = 10;
    13.         /** 对话状态1 */
    14.         private final static int DIALOAG_1 = 100;
    15.         // 场景1地图数组
    16.         int backmap0[][] = { { 1, 11, 12, 1, 76, 1, 1, 1, 78, 1, 1, 1 },
    17.                         { 19, 20, 21, 22, 73, 80, 81, 1, 77, 68, 1, 1 },
    18.                         { 28, 29, 30, 31, 32, 1, 1, 1, 1, 1, 1, 1 },
    19.                         { 37, 38, 39, 31, 41, 1, 1, 1, 1, 1, 54, 1 },
    20.                         { 46, 47, 48, 49, 50, 1, 1, 1, 1, 1, 1, 1 },
    21.                         { 55, 74, 57, 58, 59, 1, 1, 1, 1, 1, 1, 1 },
    22.                         { 79, 75, 66, 67, 1, 1, 1, 3, 4, 5, 1, 1 },
    23.                         { 1, 1, 1, 1, 1, 1, 1, 2, 13, 14, 1, 1 },
    24.                         { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
    25.                         { 54, 27, 24, 24, 23, 83, 24, 24, 24, 24, 26, 54 },
    26.                         { 15, 43, 9, 9, 23, 83, 9, 9, 9, 9, 25, 15 },
    27.                         { 54, 42, 33, 33, 23, 83, 33, 33, 33, 33, 34, 54 },
    28.                         { 1, 1, 1, 1, 84, 84, 1, 1, 1, 1, 1, 1 } };
    29.         // 图块常量
    30.         /** 每个图块的宽度 */
    31.         private final static int TILE_WIDTH = 16;
    32.         /** 每个图块的高度 */
    33.         private final static int TILE_HEIGHT = 16;
    34.         /** 场景1图片 */
    35.         Image screen_1 = null;
    36.         /** 地图原始图片 */
    37.         Image map0Img = null;
    38.         /** 人物原始图片 */
    39.         Image roleImg = null;
    40.         /** 人物的x坐标 */
    41.         int roleX = 100;
    42.         /** 任务的y坐标 */
    43.         int roleY = 100;
    44.         /** 人物宽度 */
    45.         private final static int ROLE_WIDTH = 16;
    46.         /** 人物高度 */
    47.         private final static int ROLE_HEIGHT = 32;
    48.         /** 人物方向 */
    49.         int direction;
    50.         /** 人物当前显示图片的序号 */
    51.         int currIndex = 0;
    52.         /** 人物连续移动的控制变量,-1代表不移动,其他方向和人物方向常量的规定相同 */
    53.         int roleMoveControl = -1;
    54.         /** 移动速度,每次2个像素 */
    55.         int speed = 4;
    56.         /** 不移动 */
    57.         private final static int NOT_MOVE = -1;
    58.         /** 人物方向常量 */
    59.         private final static int DIRE_LEFT = 9;
    60.         private final static int DIRE_RIGHT = 6;
    61.         private final static int DIRE_UP = 3;
    62.         private final static int DIRE_DOWN = 0;
    63.         /** 屏幕宽度 */
    64.         int width;
    65.         /** 屏幕高度 */
    66.         int height;
    67.         /** 可行走区域地图块序号 */
    68.         private int[] canMoveTile = { 1, 2, 3, 4, 5, 13, 14, 23, 32, 41, 50, 59,
    69.                         66, 67, 83 };
    70.        
    71.         /**武器名称*/
    72.         private String[] weaponName = {
    73.                 "轩辕剑",
    74.                 "浪宇刀",
    75.                 "匕首"
    76.         };
    77.        
    78.         /**武器价格*/
    79.         private int[] weaponPrice = {
    80.                 1000,
    81.                 2000,
    82.                 100
    83.         };
    84.        
    85.        
    86.        
    87.         public RPGCanvas() {
    88.                 try {
    89.                         map0Img = Image.createImage("/map.png");
    90.                         roleImg = Image.createImage("/player.png");
    91.                 } catch (Exception e) {
    92.                 }
    93.                
    94.                 //全屏
    95.                 this.setFullScreenMode(true);
    96.                
    97.                 width = this.getWidth();
    98.                 height = this.getHeight();
    99.                 // 启动线程
    100.                 Thread th = new Thread(this);
    101.                 th.start();
    102.         }
    103.         protected void paint(Graphics g) {
    104.                 // 根据游戏状态实现绘制
    105.                 switch (status) {
    106.                 case SCREEN_1:
    107.                         // 绘制场景
    108.                         paintSCREEN_1(g);
    109.                         // 绘制人物
    110.                         paintRole(g);
    111.                         break;
    112.                 case WEAPON_SHOP:
    113.                         paintWEAPON_SHOP(g);
    114.                         break;
    115.                 case DIALOAG_1:
    116.                         paintDIALOAG_1(g);
    117.                         break;
    118.                 }
    119.         }
    120.         /**
    121.          * 绘制场景1的方法
    122.          *
    123.          * @param g
    124.          *            画笔
    125.          */
    126.         private void paintSCREEN_1(Graphics g) {
    127.                 // 构造地图图片
    128.                 if (screen_1 == null) {
    129.                         screen_1 = createScreen_1();
    130.                 }
    131.                 g.drawImage(screen_1, 0, 0, Graphics.LEFT | Graphics.TOP);
    132.         }
    133.         /**
    134.          * 绘制人物
    135.          *
    136.          * @param g
    137.          *            画笔
    138.          */
    139.         private void paintRole(Graphics g) {
    140.                 g.setClip(roleX, roleY, ROLE_WIDTH, ROLE_HEIGHT);
    141.                 g.drawImage(roleImg, roleX - currIndex * ROLE_WIDTH, roleY,
    142.                                 Graphics.LEFT | Graphics.TOP);
    143.                 // 恢复默认剪切区域
    144.                 g.setClip(0, 0, width, height);
    145.         }
    146.         String weaponShopName = "武器店";
    147.         String left = "离开";
    148.         /**
    149.          * 绘制武器店界面
    150.          *
    151.          * @param g
    152.          *            画笔
    153.          */
    154.         private void paintWEAPON_SHOP(Graphics g) {
    155.                 //绘制背景
    156.                 g.setColor(0);
    157.                 g.fillRect(0, 0, width, height);
    158.                
    159.                 g.setColor(0xffffff);
    160.                
    161.                 //绘制标题
    162.                 g.drawString(weaponShopName,90,10,Graphics.TOP | Graphics.LEFT);
    163.                
    164.                 //循环绘制
    165.                 for(int i = 0; i < weaponName.length;i++){
    166.                         //绘制武器名称
    167.                         g.drawString(weaponName[i], 30,
    168.                                         50 + 30 * i, Graphics.TOP | Graphics.LEFT);
    169.                         //绘制武器价格
    170.                         g.drawString("" + weaponPrice[i], 150, 50 + 30 * i, Graphics.TOP | Graphics.LEFT);
    171.                 }
    172.                
    173.                 //绘制按钮
    174.                 g.drawString(left, 0, height, Graphics.BOTTOM | Graphics.LEFT);
    175.                
    176.         }
    177.         /**
    178.          * 绘制对话
    179.          *
    180.          * @param g
    181.          *            画笔
    182.          */
    183.         private void paintDIALOAG_1(Graphics g) {
    184.         }
    185.         private Image createScreen_1() {
    186.                 // 创建和地图大小一样的图片
    187.                 Image tempImg = Image.createImage(backmap0[0].length * TILE_WIDTH,
    188.                                 backmap0.length * TILE_HEIGHT);
    189.                 // 绘制地图
    190.                 Graphics g1 = tempImg.getGraphics();
    191.                 // 循环绘制
    192.                 for (int i = 0; i < backmap0.length; i++) { // 行
    193.                         for (int j = 0; j < backmap0[i].length; j++) {
    194.                                 // 设置剪切区域
    195.                                 g1.setClip(j * TILE_WIDTH, i * TILE_HEIGHT, TILE_WIDTH,
    196.                                                 TILE_HEIGHT);
    197.                                 // 计算图片坐标
    198.                                 int dx = (backmap0[i][j] - 1) % 9 * TILE_WIDTH;
    199.                                 int dy = (backmap0[i][j] - 1) / 9 * TILE_HEIGHT;
    200.                                 // 绘制图片
    201.                                 g1.drawImage(map0Img, j * TILE_WIDTH - dx,
    202.                                                 i * TILE_HEIGHT - dy, Graphics.LEFT | Graphics.TOP);
    203.                         }
    204.                 }
    205.                 return tempImg;
    206.         }
    207.         public void keyPressed(int keyCode) {
    208.                 //System.out.println(keyCode);
    209.                 // 根据游戏状态实现按键处理
    210.                 switch (status) {
    211.                 case SCREEN_1:
    212.                         SCREEN_1_KeyPress(keyCode);
    213.                         break;
    214.                 case WEAPON_SHOP:
    215.                         weapon_Shop_KeyPress(keyCode);
    216.                         break;
    217.                 case DIALOAG_1:
    218.                         break;
    219.                 }
    220.         }
    221.        
    222.         /**
    223.          * 武器店事件处理
    224.          * @param keyCode
    225.          */
    226.         private void weapon_Shop_KeyPress(int keyCode){
    227.                 if(keyCode == -6){ //左软键
    228.                         status = SCREEN_1; //切换到村庄
    229.                         //处理坐标
    230.                         roleX = 38;
    231.                         roleY = 100;
    232.                        
    233.                         //人物方向
    234.                         direction = DIRE_DOWN;
    235.                         //人物静止
    236.                         roleMoveControl = NOT_MOVE;
    237.                 }
    238.         }
    239.         public void keyReleased(int keyCode) {
    240.                 // 根据游戏状态实现按键处理
    241.                 switch (status) {
    242.                 case SCREEN_1:
    243.                         SCREEN_1_KeyRelease(keyCode);
    244.                         break;
    245.                 case WEAPON_SHOP:
    246.                         break;
    247.                 case DIALOAG_1:
    248.                         break;
    249.                 }
    250.         }
    251.         private void SCREEN_1_KeyPress(int keyCode) {
    252.                 // 转换为游戏动作
    253.                 int action = this.getGameAction(keyCode);
    254.                 switch (action) {
    255.                 case UP:
    256.                         // 改变方向
    257.                         direction = DIRE_UP;
    258.                         // 控制移动
    259.                         roleMoveControl = DIRE_UP;
    260.                         break;
    261.                 case DOWN:
    262.                         // 改变方向
    263.                         direction = DIRE_DOWN;
    264.                         // 控制移动
    265.                         roleMoveControl = DIRE_DOWN;
    266.                         break;
    267.                 case LEFT:
    268.                         // 改变方向
    269.                         direction = DIRE_LEFT;
    270.                         // 控制移动
    271.                         roleMoveControl = DIRE_LEFT;
    272.                         break;
    273.                 case RIGHT:
    274.                         // 改变方向
    275.                         direction = DIRE_RIGHT;
    276.                         // 控制移动
    277.                         roleMoveControl = DIRE_RIGHT;
    278.                         break;
    279.                 case FIRE:
    280.                         break;
    281.                 }
    282.         }
    283.         private void SCREEN_1_KeyRelease(int keyCode) {
    284.                 // 转换为游戏动作
    285.                 int action = this.getGameAction(keyCode);
    286.                 switch (action) {
    287.                 case UP:
    288.                 case DOWN:
    289.                 case LEFT:
    290.                 case RIGHT:
    291.                         roleMoveControl = NOT_MOVE;
    292.                 }
    293.         }
    294.         Runtime rt = Runtime.getRuntime();
    295.         public void run() {
    296.                 try {
    297.                         while (true) {
    298.                                 // 延时
    299.                                 Thread.sleep(100);
    300.                                 // 逻辑处理方法
    301.                                 tick();
    302.                                
    303.                                 //判断
    304.                                 if(rt.freeMemory() < 100000){
    305.                                         System.gc();
    306.                                 }
    307.                                 // 重新绘制
    308.                                 repaint();
    309.                         }
    310.                 } catch (Exception e) {
    311.                 }
    312.         }
    313.         /**
    314.          * 逻辑处理方法
    315.          */
    316.         public void tick() {
    317.                 // 根据游戏状态实现绘制
    318.                 switch (status) {
    319.                 case SCREEN_1:
    320.                         roleMove();
    321.                         break;
    322.                 case WEAPON_SHOP:
    323.                         break;
    324.                 case DIALOAG_1:
    325.                         break;
    326.                 }
    327.         }
    328.         /**
    329.          * 人物移动处理方法
    330.          */
    331.         private void roleMove() {
    332.                 if (roleMoveControl != NOT_MOVE) { // 人物移动
    333.                         //是否进入武器店
    334.                         if(isDisplayWeaponShop()){
    335.                                 status = WEAPON_SHOP;
    336.                         }
    337.                         // 根据方向移动
    338.                         switch (direction) {
    339.                         case DIRE_LEFT:
    340.                                 // 向左移动
    341.                                 // 左边界检测
    342.                                 if (roleX - speed >= 0) {
    343.                                         roleX -= speed;
    344.                                         // 如果发生碰撞,则退回
    345.                                         if (collis()) {
    346.                                                 roleX += speed;
    347.                                         }
    348.                                 }
    349.                                 break;
    350.                         case DIRE_RIGHT:
    351.                                 // 向右移动
    352.                                 // 右边界检测
    353.                                 if (roleX + ROLE_WIDTH + speed <= width) {
    354.                                         roleX += speed;
    355.                                         // 如果发生碰撞,则退回
    356.                                         if (collis()) {
    357.                                                 roleX -= speed;
    358.                                         }
    359.                                 }
    360.                                 break;
    361.                         case DIRE_UP:
    362.                                 // 向上移动
    363.                                 // 上边界检测
    364.                                 if (roleY - speed >= 0) {
    365.                                         roleY -= speed;
    366.                                         // 如果发生碰撞,则退回
    367.                                         if (collis()) {
    368.                                                 roleY += speed;
    369.                                         }
    370.                                 }
    371.                                 break;
    372.                         case DIRE_DOWN:
    373.                                 // 向下移动
    374.                                 // 下边界检测
    375.                                 if (roleY + ROLE_HEIGHT + speed <= height) {
    376.                                         roleY += speed;
    377.                                         // 如果发生碰撞,则退回
    378.                                         if (collis()) {
    379.                                                 roleY -= speed;
    380.                                         }
    381.                                 }
    382.                                 break;
    383.                         }
    384.                         // 动画
    385.                         if (currIndex == direction + 1) {
    386.                                 currIndex = direction + 2;
    387.                         } else {
    388.                                 currIndex = direction + 1;
    389.                         }
    390.                 } else { // 人物静止
    391.                         currIndex = direction;
    392.                 }
    393.         }
    394.         /**
    395.          * 碰撞检测
    396.          * 原理:以人物16X32区域的下半部12X12和地图坐标判断,
    397.          * 只有地图块 为可移动地图块数组的才能够行走
    398.          *
    399.          * @return true代表发生碰撞,false代表未碰撞
    400.          */
    401.         private boolean collis() {
    402.                 // 获得12X12区域的坐标,左上角
    403.                 int leftX = roleX + 2;
    404.                 int topY = roleY + 18;
    405.                 // 计算左上角所在的地图图块的序号
    406.                 int col = leftX / TILE_WIDTH;
    407.                 int row = topY / TILE_HEIGHT;
    408.                 if (!canMove(row, col)) {
    409.                         return true;
    410.                 }
    411.                 // 右上角所在的地图图块的序号
    412.                 col = (leftX + 12) / TILE_WIDTH;
    413.                 if (!canMove(row, col)) {
    414.                         return true;
    415.                 }
    416.                 // 左下角所在的地图图块的序号
    417.                 col = leftX / TILE_WIDTH;
    418.                 row = (topY + 12) / TILE_WIDTH;
    419.                 if (!canMove(row, col)) {
    420.                         return true;
    421.                 }
    422.                 // 右下角
    423.                 col = (leftX + 12) / TILE_WIDTH;
    424.                 if (!canMove(row, col)) {
    425.                         return true;
    426.                 }
    427.                 // 如果都不满足,则返回false
    428.                 return false;
    429.         }
    430.         /**
    431.          * 第row行第col列图块是否可行走
    432.          *
    433.          * @param row
    434.          *            行号,从0开始
    435.          * @param col
    436.          *            列号,从0开始
    437.          * @return true代表可以行走,false代表不能行走
    438.          */
    439.         private boolean canMove(int row, int col) {
    440.                 boolean b = false;
    441.                 for (int i = 0; i < canMoveTile.length; i++) {
    442.                         if (backmap0[row][col] == canMoveTile[i]) {
    443.                                 b = true;
    444.                                 break;
    445.                         }
    446.                 }
    447.                 return b;
    448.         }
    449.        
    450.         /**
    451.          * 是否进入武器店
    452.          * @return true代表进入
    453.          */
    454.         private boolean isDisplayWeaponShop(){
    455.                 // 获得16X16区域的坐标,左上角
    456.                 int leftX = roleX;
    457.                 int topY = roleY + 16;
    458.                 // 计算左上角所在的地图图块的序号
    459.                 int col = leftX / TILE_WIDTH;
    460.                 int row = topY / TILE_HEIGHT;
    461.                 //是否和门发生碰撞
    462.                 if(backmap0[row][col] == 66){ //门
    463.                         //status = WEAPON_SHOP;
    464.                         return true;
    465.                 }               
    466.                 // 右上角所在的地图图块的序号
    467.                 col = (leftX + 12) / TILE_WIDTH;
    468.                 //是否和门发生碰撞
    469.                 if(backmap0[row][col] == 66){ //门
    470.                         //status = WEAPON_SHOP;
    471.                         return true;
    472.                 }
    473.                
    474.                 return false;
    475.         }
    476. }
    复制代码


      
       
         
         
          
          
            
          
                         
            
          
         
       

      


    源码下载:http://file.javaxxz.com/2014/10/11/040126250.zip
    回复

    使用道具 举报

    您需要登录后才可以回帖 登录 | 立即注册

    本版积分规则

    QQ|手机版|Java学习者论坛 ( 声明:本站资料整理自互联网,用于Java学习者交流学习使用,对资料版权不负任何法律责任,若有侵权请及时联系客服屏蔽删除 )

    GMT+8, 2024-5-2 18:11 , Processed in 0.373078 second(s), 34 queries .

    Powered by Discuz! X3.4

    © 2001-2017 Comsenz Inc.

    快速回复 返回顶部 返回列表