Java版AVG游戏开发入门[1] —— CG的绘制

简介:
作为Adventure Game,AVG的图文部分向来便是整个游戏的核心之一,所以本回将以图像绘制为中心讲解AVG的CG生成问题。(CG,即Computer Graphics,直译可称[计算机图形],此处以其为AVG开发中图形部分的代称)。
 
 
在小时候,我们或许会被AVG游戏的华丽特效所折服。但现在,我们都知道完成那些不过是程序员的最基本能力罢了,即使不是专业的游戏开发者,也可以轻易做到。
 
众所周知,Java中图像绘制是非常容易的事情,无论您是通过ImageIO、ImageIcon或 Toolkit.getDefaultToolkit().createImage乃至其他方式取得Image(或BufferedImage),处理的 方式都完全相同的,即通过Graphics。
 
Graphics是一个抽象类,因此通常需要Image来引入其实例。
 
在Java AWT相关包内,Graphics的基本用法如下所示。
 
 
  1. Public void paint(Graphics g){  
  2.  //设定颜色  
  3.  g.setColor(…);  
  4.  //设定字体  
  5.  g.setFont(…);  
  6.  //绘制文本  
  7.  g.drawString(…);  
  8.  //绘制线段  
  9.  g.drawLine(…);  
  10.  //绘制矩形  
  11.  g.drawRect(…);  
  12.  //填充矩形  
  13.  g.fillRect(…);  
  14.  //绘制椭圆  
  15.  g.drawOval(…);  
  16.  //填充椭圆  
  17.  g.fillOval(…);  
  18.  //绘制多边形  
  19. g.drawPolygon(…);  
  20. //填充多边形  
  21. g.fillPolygon(…);  
  22. //显示图像  
  23. g.drawImage(…);  
  24. //其它请参考相关文档  
  25. //…  
  26. }   
 
但是,对于一些高级效果,则需要通过Graphics2D解决。
 
Graphics2D同样是一个抽象类, 继承自Graphics ,并且扩展了 Graphics,提供了对几何形状、坐标转换、颜色管理和文本布局更为复杂的控制。它是用于在Java平台上呈现二维形状、文本和图像高级特性的基础类。
 
由于Graphics2DGraphics的子类,故此可以直接转换Graphics获得。
 
Java AWT 相关包内, Graphics2D 的基本用法如下所示。
 
  1. Public void paint(Graphics g){  
  2.   //获得Graphics2D实例  
  3. Graphics2D g2d = (Graphics2D) g;  
  4. //原Graphics部分  
  5.  //设定颜色  
  6.  g2d.setColor(…);  
  7.  //设定字体  
  8.  g2d.setFont(…);  
  9.  //绘制文本  
  10.  g2d.drawString(…);  
  11.  //绘制线段  
  12.  g2d.drawLine(…);  
  13.  //绘制矩形  
  14.  g2d.drawRect(…);  
  15.  //填充矩形  
  16.  g2d.fillRect(…);  
  17.  //绘制椭圆  
  18.  g2d.drawOval(…);  
  19.  //填充椭圆  
  20.  g2d.fillOval(…);  
  21.  //绘制多边形  
  22. g2d.drawPolygon(…);  
  23. //填充多边形  
  24. g2d.fillPolygon(…);  
  25. //显示图像  
  26. g2d drawImage(…);  
  27. //Graphics2D部分新增功能  
  28. //设置Paint  
  29. g2d.setPaint(…);  
  30. //设置线条粗细  
  31. g2d.setStroke(…);  
  32. //设置Composite(多用AlphaComposite)  
  33. g2d.setComposite(…);  
  34. //设置移动边距  
  35. g2d.translate(…);  
  36. //设置刻度  
  37. g2d.scale(…);  
  38. //设置旋转  
  39. g2d.rotate(…);  
  40. //设置剪裁  
  41. g2d.shear(…);  
  42. //设置坐标变形  
  43. g2d.setTransform(…);  
  44. //创建特定Shape实例  
  45. Shape shape=new YourShape(…);  
  46. //设定指定Shape  
  47. g2d.draw(shape);  
  48. //填充指定Shape  
  49. g2d.draw(shape);  
  50. //设定RenderingHints(绘图微调设定用类)  
  51. g2d.setRenderingHint(…);  
  52. //其它请参考相关文档  
  53. //…  
  54. }  
 
无论代码构建的如何复杂,Java绘图的基本流程也仅仅是Image-> Graphics->Paint罢了,只需利用一个循环的repaint函数,我们就可以无数次重复这一流程。由于在我先前其它博文中已多有涉及,故此处不再赘述。
 
说到底,AVG游戏中的CG产生,也无非是一次次将图像混合后展现出来,是这一流程的简单再现。
 
具体合成关系如下图所示:
 
 
 
就我个人认为,在2D的AVG中,分层仅需区别前景及背景两层即可。
 
原因在于,Graphics或Graphics2D在drawImage时,将顺序绘制图像,旧图会被新图所覆盖。故此,即使图像再多,也不过是在交替背景前景产生的过程,一次次覆盖,一次次交替,最终令唯一的CG被绘制到屏幕上去。
 
因而我们也可以得出一个AVG游戏开发的最基本概念,即图像添加时,背景图像添加应始终在前,前景图像添加需始终在后,图像的活动部分始终作为前景,而将非活动部分始终作为背景。
 
在本文的示例程序中,具体实现代码如下(详细请下载):
 
    
  1. public void draw(final Graphics g) {  
  2.         if (sleep <= 0) {  
  3.             if (cg.getBackgroundCG() != null) {  
  4.                 if (shakeNumber > 0) {  
  5.                     graphics.drawImage(cg.getBackgroundCG(), shakeNumber / 2  
  6.                             - Control.rand.nextInt(shakeNumber), shakeNumber  
  7.                             / 2 - Control.rand.nextInt(shakeNumber), null);  
  8.                 } else {  
  9.                     graphics.drawImage(cg.getBackgroundCG(), 00null);  
  10.                 }  
  11.             }  
  12.             for (int i = 0; i < cg.getCharas().size(); i++) {  
  13.                 Chara chara = (Chara) cg.getCharas().get(i);  
  14.                 graphics.drawImage(chara.getCharacterCG(), chara.getX(), chara  
  15.                         .getY(), null);  
  16.             }  
  17.             if (isMessage) {  
  18.                 dialog.showDialog(dialogImage, graphics);  
  19.                 for (int i = 0; i < stringMaxLine; i++) {  
  20.                     graphics.setColor(Color.black);  
  21.                     for (int j = 0; j < messages[i].length(); j++) {  
  22.                         Utility.drawString(messages[i].substring(j, j + 1)  
  23.                                 .toString(), Lib.fontName, graphics, Lib.FONT  
  24.                                 * j + dialog.getMESSAGE_LINE_X() + 2, i  
  25.                                 * (Lib.FONT + Lib.FONT_SIZE) + Lib.FONT + 1  
  26.                                 + dialog.getMESSAGE_LINE_Y(), 1);  
  27.                     }  
  28.                     if (flags[selectFlag] != -1) {  
  29.                         graphics.setColor(Color.white);  
  30.                         for (int j1 = 0; j1 < messages[selectFlag].length(); j1++) {  
  31.                             Utility.drawString(messages[selectFlag].substring(  
  32.                                     j1, j1 + 1).toString(), Lib.fontName,  
  33.                                     graphics, Lib.FONT * j1  
  34.                                             + dialog.getMESSAGE_LINE_X(),  
  35.                                     selectFlag * (Lib.FONT + Lib.FONT_SIZE)  
  36.                                             + Lib.FONT  
  37.                                             + dialog.getMESSAGE_LINE_Y(), 1);  
  38.                         }  
  39.                         dialog.showDialog(selectFlag, Lib.FONT, Lib.FONT_SIZE,  
  40.                                 dialogImage, graphics);  
  41.                     }  
  42.                     if (flags[i] == -1) {  
  43.                         graphics.setColor(Color.white);  
  44.                     } else {  
  45.                         graphics.setColor(Color.gray);  
  46.                     }  
  47.                     for (int count = 0; count < messages[i].length(); count++) {  
  48.                         Utility.drawString(messages[i].substring(count,  
  49.                                 count + 1).toString(), Lib.fontName, graphics,  
  50.                                 Lib.FONT * count + dialog.getMESSAGE_LINE_X(),  
  51.                                 i * (Lib.FONT + Lib.FONT_SIZE) + Lib.FONT  
  52.                                         + dialog.getMESSAGE_LINE_Y(), 1);  
  53.                     }  
  54.                 }  
  55.             }  
  56.         } else {  
  57.             sleep--;  
  58.             if (color != null) {  
  59.                 graphics.setColor(color);  
  60.                 graphics.fillRect(00, Lib.WIDTH, Lib.HEIGHT);  
  61.                 Utility.wait(20);  
  62.             }  
  63.         }  
  64.         // 设置背景  
  65.         g.drawImage(screen, 00null);  
  66.         g.dispose();  
  67.     }  
  
 
下一次,我们将开始讲解AVG的剧情发展及脚本定制。
 
示例代码界面如下图:
 
  
 
 
  
 
  
 
  
 
   示例程序下载地址:[url]http://download.csdn.net/source/999273[/url](源码在jar内)


本文转自 cping 51CTO博客,原文链接:http://blog.51cto.com/cping1982/130277
相关文章
|
4天前
|
存储 安全 Java
【Java并发】【原子类】适合初学体质的原子类入门
什么是CAS? 说到原子类,首先就要说到CAS: CAS(Compare and Swap) 是一种无锁的原子操作,用于实现多线程环境下的安全数据更新。 CAS(Compare and Swap) 的
38 15
【Java并发】【原子类】适合初学体质的原子类入门
|
4天前
|
Java
【源码】【Java并发】【LinkedBlockingQueue】适合中学体质的LinkedBlockingQueue入门
前言 有了前文对简单实用的学习 【Java并发】【LinkedBlockingQueue】适合初学体质的LinkedBlockingQueue入门 聪明的你,一定会想知道更多。哈哈哈哈哈,下面主播就...
32 6
【源码】【Java并发】【LinkedBlockingQueue】适合中学体质的LinkedBlockingQueue入门
|
5天前
|
安全 Java
【Java并发】【ArrayBlockingQueue】适合初学体质的ArrayBlockingQueue入门
什么是ArrayBlockingQueue ArrayBlockingQueue是 Java 并发编程中一个基于数组实现的有界阻塞队列,属于 java.util.concurrent 包,实现了 Bl...
41 6
【Java并发】【ArrayBlockingQueue】适合初学体质的ArrayBlockingQueue入门
|
12天前
|
监控 Java API
【Java并发】【ReentrantLock】适合初学体质的ReentrantLock入门
前言 什么是ReentrantLock? ReentrantLock 是 Java 并发包 (java.util.concurrent.locks) 中的一个类,它实现了 Lock 接口,提供了与
57 10
【Java并发】【ReentrantLock】适合初学体质的ReentrantLock入门
|
4天前
|
安全 Java
【Java并发】【LinkedBlockingQueue】适合初学体质的LinkedBlockingQueue入门
前言 你是否在线程池工具类里看到过它的身影? 你是否会好奇LinkedBlockingQueue是啥呢? 没有关系,小手手点上关注,跟上主播的节奏。 什么是LinkedBlockingQueue? ...
25 1
【Java并发】【LinkedBlockingQueue】适合初学体质的LinkedBlockingQueue入门
|
1月前
|
设计模式 存储 安全
【Java并发】【AQS】适合初学者体质的AQS入门
AQS这是灰常重要的哈,很多JUC下的框架的核心,那都是我们的AQS,所以这里,我们直接开始先研究AQS。 那说到研究AQS,那我们应该,使用开始说起🤓 入门 什么是AQS? AQS(Abst
63 8
【Java并发】【AQS】适合初学者体质的AQS入门
|
1月前
|
缓存 安全 Java
【Java并发】【synchronized】适合初学者体质入门的synchronized
欢迎来到我的Java线程同步入门指南!我不是外包员工,梦想是写高端CRUD。2025年我正在沉淀中,博客更新速度加快,欢迎点赞、收藏、关注。 本文介绍Java中的`synchronized`关键字,适合初学者。`synchronized`用于确保多个线程访问共享资源时不会发生冲突,避免竞态条件、保证内存可见性、防止原子性破坏及协调多线程有序访问。
61 8
【Java并发】【synchronized】适合初学者体质入门的synchronized
|
2月前
|
存储 监控 Java
【Java并发】【线程池】带你从0-1入门线程池
欢迎来到我的技术博客!我是一名热爱编程的开发者,梦想是编写高端CRUD应用。2025年我正在沉淀中,博客更新速度加快,期待与你一起成长。 线程池是一种复用线程资源的机制,通过预先创建一定数量的线程并管理其生命周期,避免频繁创建/销毁线程带来的性能开销。它解决了线程创建成本高、资源耗尽风险、响应速度慢和任务执行缺乏管理等问题。
195 60
【Java并发】【线程池】带你从0-1入门线程池
|
11天前
|
Java 中间件 调度
【源码】【Java并发】从InheritableThreadLocal和TTL源码的角度来看父子线程传递
本文涉及InheritableThreadLocal和TTL,从源码的角度,分别分析它们是怎么实现父子线程传递的。建议先了解ThreadLocal。
48 4
【源码】【Java并发】从InheritableThreadLocal和TTL源码的角度来看父子线程传递
|
1月前
|
存储 网络协议 安全
Java网络编程,多线程,IO流综合小项目一一ChatBoxes
**项目介绍**:本项目实现了一个基于TCP协议的C/S架构控制台聊天室,支持局域网内多客户端同时聊天。用户需注册并登录,用户名唯一,密码格式为字母开头加纯数字。登录后可实时聊天,服务端负责验证用户信息并转发消息。 **项目亮点**: - **C/S架构**:客户端与服务端通过TCP连接通信。 - **多线程**:采用多线程处理多个客户端的并发请求,确保实时交互。 - **IO流**:使用BufferedReader和BufferedWriter进行数据传输,确保高效稳定的通信。 - **线程安全**:通过同步代码块和锁机制保证共享数据的安全性。
83 23