软件开发和设计思想

21世纪合格人才必备7大技能 zt

牛阿牛-野狼穴 — Mon, 23 May 2005 00:15:00 GMT

21世纪合格人才必备7大技能
转自Hao360英语学习宝库：http://www.hao360.com/page/details.asp?id=6267

　　SEVEN SKILLS FOR QUALIFIED EMPLOYEES IN 21ST CENTURY

　　21世纪合格人才必备7大技能

　　Technical and technological skills will take on greater importance. There will be a growing need for people who can understand and fix systems--from computer systems to product distribution systems to plumbing systems.

　　Visionary skills will be in demand. The ability to gather and absorb a wide range of input ,then use that knowledge, understanding, and perspective to guide organization into future, will be vital.

　　Numbers and measurement will be important, of course, but smoothing the flow form month to month, from quarter to quarter will be essential for highly profitable long-term performance. Practically every company will have to move away from today's obsession with looking ahead only as far as the next financial reporting period.

　　Ability to organize will definitely be important in the corporation of the future. Everywhere there will be a need to organize something: resources, workflow, marketing mix, financial opportunities, and much more, all will demand high levels of organization and reorganization.

　　Persuasive skills will be used in many ways by the corporation of the future, the most-effective individuals will be those who know how to present information and ideas so that others can understand and support a particular position. Good salesmanship will be essential in many more interactions than we consider today, especially inside the organization.

　　Communication skills--careful listening, clear writing, close reading, plain speaking, and accurate description--will be invaluable. In tomorrow's fast-paced business environment there will be precious little time to correct any misunderstandings. Communications breakdown may well become a fatal corporate disease.

　　Ability to learn will be above everything else in importance--empowering people to grow in effectiveness and help their companies achieve desired objectives. Some of this skill is innate, but many people enhance their ability to learn--and to relate different aspects of learning--through college and university courses. We believe the liberal arts education experience will prove to be the most valuable type of education for tomorrow's leaders.

　　The top employees of the coming century will be flexible, creative and motivated toward making a positive difference in the world. They will seek balance, growth and fulfillment in both their work and home environments. The corporation of the future must respond to these needs and desires; otherwise they will find themselves hampered by a lack of qualified people to accomplish the organization's work.

　　译文：21世纪合格人材必备7大技能

　　1．技术专长与创新能力--将更加重要。今后将越来越需要在计算机、产品推销和管道工程等方面既懂理论又有实践经验的人。

　　2．想像能力--将是一种需要。这种能力至关重要，它可收集和获取广泛而大量的知识信息，并对其中一些知识、思维方法及观察视角加以借鉴，以便引导公司走向未来。

　　3．数字与计算--固然很重要，但是保证月与月之间的衔接、部门与部门的配合都顺利通畅将是实现长期高效运作的关键所在。实际上，每个公司都必须改变那种只做下一个财政年度计划的错误观念。

　　4．组织能力--在未来的公司的运作中无疑是十分重要的。无论到哪儿，组织工作都是必不可少的，如调拨财力物力、设置工作流程、制定市场营销战略、寻找赢利机会等等，所有这些都需要高水平的组织与改组能力。

　　5.说服能力--将以各种方式在未来公司中发挥作用。工作最有成效的员工将是那些懂得如何表达信息和思想以便能够得到别人理解与支持的人，出色的游说能力在未来更多的人际交往中将是必不可少的，特别是在公司内部。

　　6．交流能力--听得认真、写得明白、看得仔细、说得清楚、叙述准确--将具有无可估量的价值。在未来快节奏的工作环境中，人们惜时如金，容不得半，点疏漏。交流障碍很可能成为未来公司致命的问题。

　　7．学习能力--将在上述各种能力中占据最重要的地位，因为它使人能够提高工作效率，帮助自己的公司达到预期目的。这种能力一部分来自个人夭赋，当然也有不少人通过接受高等教育提高自己的气习能力和各种知识的融会贯通能力。我们认为，大学文科教育积累的经验将证明是对明天的领导者们最有价值的教育形式。

　　21世纪最出色的公司雇员将富有灵活性和创造性，并有志于做出不同凡响的创举。他们将在事业和家庭两方面寻求平衡、发展与完善。未来的公司必须对雇员必备技能加以考核，否则，公司的发展就会困工作中缺乏合格人才而受限制。

转自Hao360英语学习宝库：http://www.hao360.com/page/details.asp?id=6267

使用Jbulider开发j2me程序 zt 作者：syngle 文章来源：原创点击数：1844 更新时间：2005-1-12

牛阿牛-野狼穴 — Sat, 21 May 2005 07:01:00 GMT

承蒙版主看得起，写篇关于怎样使用JBuilder开发j2me程序的例子。错误遗漏之处，还望各位指正~~
本人使用JBuilder2005,赶下时髦，呵呵~~2005自带WTK2.1，自己下载2.2版本，2.2那个默认的模拟器看着实在爽，^_^。另外,Jbuilder X下的WTK也是2.0的版本好象。Jbuilder 9的WTK是1.04。
首先开启Jbuilder.建立一个Project。

然后填写名字和路径。继续：

然后选择JDK路径，本身已有WTK2.1，你可以选择。但是你也可以自己选择其他的WTK版本。

点击jdk后面的路径按钮,继续:

然后ok,next.工程建立完毕.

接着点击file->New:

然后在对话框左边选择Micro,你就能看到右边出现MIDlet,Displayable.

接上面的:如图示

点击MIDlet or Displayable,则让你输入MIDlet的名字.如图:

继续下一步,让你输入一个Displayable的名字,包括类型(form,canvas等),是否自动加载Command

等等

然后Jbuilder自动生成所需代码,以及Jbuilder自加的一些东西.你可以添加或修改之.

这里我将本站一篇关于介绍Gamecanvas的文章的代码拿过来,做少量修改,作为本文章的一个演示;

TestMIDlet.java文件:

package temps;

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

/**
* Title: 
*
* Description: 
*
* Copyright: Copyright (c) 2005
*
* Company: 
*
* @author not attributable
* @version 1.0
*/
public class TestMIDlet extends MIDlet
{
private Display display;

    public void startApp()
    {
        try
        {
            display = Display.getDisplay(this);
            Displayable1 gameCanvas = new Displayable1();
            gameCanvas.start();
            display.setCurrent(gameCanvas);
        }
        catch (Exception ex)
        {
            System.out.println(ex);
        }
    }

    public Display getDisplay()
    {
        return display;
    }

    public void pauseApp()
    {
    }

    public void destroyApp(boolean unconditional)
    {
        exit();
    }

    public void exit()
    {
        System.gc();
        destroyApp(false);
        notifyDestroyed();
    }
}

Displayable1.java内容:

package temps;

import javax.microedition.lcdui.*;
import java.util.Random;
import javax.microedition.lcdui.game.*;
/**
* Title: 
*
* Description: 
*
* Copyright: Copyright (c) 2005
*
* Company: 
*
* @author not attributable
* @version 1.0
*/
public class Displayable1 extends GameCanvas implements Runnable
{
 private boolean isPlay; // Game Loop runs when isPlay is true
 private long delay; // To give thread consistency
 private int currentX, currentY; // To hold current position of the 'X'
 private int width; // To hold screen width
 private int height; // To hold screen height
 private Random random=new Random(System.currentTimeMillis());
 private final int[] sequence={0,1,2,1,0,1,2,1,0,1,2,1,1,1,1,1,1};
 private int counter=0;
 private int enemyX,enemyY;
 private int enemyDirect=0;
 private boolean isdown=false;

private boolean isalive=true;

    // Sprites to be used
    private Sprite playerSprite;
    private Sprite backgroundSprite;
    private Sprite enemySprite;

// Layer Manager
private LayerManager layerManager;

    // Constructor and initialization
    public Displayable1() throws Exception
    {
        super(true);
        width = getWidth();
        height = getHeight();

        currentX = width / 2;
        currentY = height / 2;
        enemyX=width/4;
        enemyY=height/4;
        delay = 100;

        Image playerImage=null;
        Image backgroundImage=null;
        Image enemy=null;
        // Load Images to Sprites
        try
        {
            playerImage = Image.createImage("/transparent.png");
            backgroundImage = Image.createImage("/background.png");
            enemy=Image.createImage("/frames.png");
        }
        catch(Exception e)
        {
            System.out.println("get Image error!"+e.getMessage());
        }

        playerSprite = new Sprite(playerImage, 32, 32);
        System.out.println(playerSprite.getRawFrameCount());
        enemySprite=new Sprite(enemy,50,21);
        backgroundSprite = new Sprite(backgroundImage);
        layerManager = new LayerManager();
        layerManager.append(playerSprite);
        layerManager.append(enemySprite);
        layerManager.append(backgroundSprite);

}

    // Automatically start thread for game loop
    public void start()
    {
        isPlay = true;
        Thread t = new Thread(this);
        t.start();
    }

    public void stop()
    {
        isPlay = false;
    }

    // Main Game Loop
    public void run()
    {
        Graphics g = getGraphics();
        while (isPlay == true)
        {
            input();
            drawScreen(g);
            try
            {
                Thread.sleep(delay);
            }
            catch (InterruptedException ie)
            {

            }
        }
    }

    // Method to Handle User Inputs
    private void input()
    {
        int keyStates = getKeyStates();

        playerSprite.setFrame(0);
        if(isalive)
        {
            if(counter==0)
            {
                enemyDirect=Math.abs(random.nextInt()%4);
            }
            counter++;
            switch(enemyDirect)
            {
                case 0:
                    enemyY=Math.max(0,--enemyY);
                    break;
                case 1:
                    enemyY=Math.min(++enemyY,height-enemySprite.getHeight());
                    break;
                case 2:
                    enemyX=Math.max(0,--enemyX);
                    break;
                case 3:
                    enemyX=Math.min(++enemyX,width-enemySprite.getWidth());
                    break;
            }
            counter=(counter++)%(sequence.length());
            enemySprite.setFrame(sequence[counter]);
        }
        else
        {
            enemyY+=counter;
            enemyY=Math.min(enemyY,height-enemySprite.getHeight());

if(enemyY<height-enemySprite.getHeight())
 counter++;
 enemySprite.setFrame(3);
 }

        // Left
        if ((keyStates & LEFT_PRESSED) != 0)
        {
            currentX = Math.max(0, currentX - 1);
            playerSprite.setFrame(1);
        }

// Right
 if ((keyStates & RIGHT_PRESSED) != 0)
 if (currentX + 5 < width)
 {
 currentX = Math.min(width, currentX + 1);
 playerSprite.setFrame(3);
 }

        // Up
        if ((keyStates & UP_PRESSED) != 0)
        {
            currentY = Math.max(0, currentY - 1);
            playerSprite.setFrame(2);
        }

        // Down
        if ((keyStates & DOWN_PRESSED) != 0)
        {
            isdown=true;
        }

if ((keyStates & DOWN_PRESSED) != 0)
 {
 if(isdown)
 {
 if (currentY + 10 < height)
 {
 currentY = Math.min(height, currentY + 1);
 playerSprite.setFrame(4);
 }
 }
 }

        if((keyStates & FIRE_PRESSED)!=0)
        {
            isalive=!isalive;
            counter=0;
        }

if(!(enemyX+enemySprite.getWidth()<currentX || enemyY+enemySprite.getHeight()<currentY || enemyX>currentX+playerSprite.getWidth() || enemyY>currentY+playerSprite.getHeight()) && isalive)
 {
 counter=0;
 isalive=false;
 }
 }

    // Method to Display Graphics
    private void drawScreen(Graphics g)
    {
        g.setColor(0xffffff);
        g.fillRect(0, 0, getWidth(), getHeight());
        g.setColor(0x0000ff);

        // updating player sprite position
        playerSprite.setPosition(currentX, currentY);
        enemySprite.setPosition(enemyX,enemyY);

layerManager.setViewWindow(0, 0, width, height);
layerManager.paint(g, 0,0);

        g.setColor(0xffffff);
        flushGraphics();
    }

}

此程序里敌人随机向4个方向移动,而玩家控制的角色可任意移动, 如果两者发生碰撞,则敌人死亡.

另外按fire键可直接让敌人生或死,呵呵~~

关于运行,Jbuilder里有个运行配置:

一般不用修改,如果多个Midlet,你可以在这里添加.

关于用Jbuilder打包.

一样file->new:

这个在2005和9,x里有所不同,选择Archive,右边选择MIDlet,然后ok.

这里选择要打包文件的目录,当前默认是所有的class文件和资源文件,你也可以删除掉,自己选择一部分.

然后next,直到最后. 然后运行,在运行配置中默认重新rebuild,打包等等.然后你能看到左上框里有jar文件和jad文件.

运行结果:

呵呵,用你控制的主角去碰撞这只大飞虫试试:

结果飞虫挂了,掉下去了哦,呵呵~~

全文完~~~

何苦编程

牛阿牛-野狼穴 — Tue, 17 May 2005 08:45:00 GMT

何苦编程

牛阿牛

2005-05-17

nhf_2008@hotmail.com

勤学好问，勿用质疑。勤奋学习，耐心思考之后，问才有意义。大家都接受的道理，不知为什么在软件开发上，大家却又忘记了。

一遇到问题，就开始四处查找源代码。固然，站在别人的肩膀上，大家的发展可以更快，更好。可是扪心自问一下，我们作了不少工作，可是有多少源自我们自己的思考，可以说成自己开发的东西呢？到处都是在拷贝代码，到处都是问一个东西的开发思路。

大家耐心想一想，每一件工作是否真的追得很急，是否我们真的无法自己独立完成？还是我们浮躁，不自信。

这样的结果是什么，是我们从来都是把现有的东西堆砌在一起，甚或说起具体的实现过程，自己还很难说出个所以然来。不知，这样下去，我们的软件开发有什么意义。小的逻辑处理都不能独立解决，大的系统结构更难处理吧。

编程是一件快乐的事情，是自豪的。每当我们从电脑旁抬起会心的笑容时，我们知道，我们又一次走出了新的一步。四处查找源码，不加理解的套用，只会让我们对别人更加依赖，对软件开发的更加缺乏了解，甚或后期的工作更难维护。

俄罗斯算法，华容道算法等等，真的很难吗？大家既然选择了软件开发，在独立解决问题能力，数学逻辑方面都应该有相当的基础。我觉得如果这些问题，个人都不能仔细思考一下，然后解决。选择开发是绝对是你的错误。

有感而发，不对个人，希望大家能有更多的共识。

完美的软件项目开发团队结构（来自微软） zt

牛阿牛-野狼穴 — Thu, 12 May 2005 09:17:00 GMT

完美的软件项目开发团队结构（来自微软）

项目经理团队(Program Management Team):
    设计项目经理(Feature Design PM): 负责具体的产品设计，写Design Spec。PM 队伍中，80%的PM是做这个。
    发行项目经理(Release PM): 负责整个项目的流程和进度管理，制定进度表等，协调整个团队的工作。大的PM 队伍中有一人专门做这个。这是整个项目的领头人。大型的项目的成功与否，常常靠得力的发行经理的领导。
    协助项目经理(Supporting PM): 负责其它产品发行需要照顾到的事情，如客户交流、和市场开发人员交流、负责beta program (初版试行)、等等。大的PM 队伍中少不了这样的人。20%的PM是做这个。

开发团队(Development Team):
    开发团队领导(Development Manager): 负责管理各个开发小组，并对开发编程的工作做总体的规划。
    开发组长(Development Lead): 负责管理开发工程师，也参加对开发编程的工作做总体的规划。
    开发工程师(Develop Engineer, or Developer): 负责具体的编程开发。
    构架师(Architect): 大的产品团队有一两个资深工程师专门做整体系统的设计规划。

测试团队(Quality Assurance or Test Team):
    测试团队领导(QA Manager): 负责管理测试小组
    测试组长(Test Lead): 负责管理测试工程师, 制定测试计划等
    测试工程师(Tester or Test Engineer): 负责具体的测试工作
    测试开发工程师(Developer in Test, or STED): 负责测试工具的开发

产品可用性团队(Usability Team):
    产品可用性工程师 (Usability Engineer): 做使用性能的调查和测试，采访客户或将客户邀请来做调查
    界面设计师(UI Designer): 负责具体的界面设计
    产品设计师(Product Designer): 负责产品的总体设计，特别是硬件产品。
以上这个团队并不是所有的产品队伍都有。比较小的队伍就没有这些专人，有的时候向别的队伍借用，或雇佣临时工。

客户教育或文档团队(User Education, or UE Team):
文档组长(UE Lead): 负责管理文档小组
文档编辑(UE Editor): 负责具体的文档编辑和撰写

射击游戏中跟踪弹及小角度移动的开发

牛阿牛-野狼穴 — Fri, 22 Apr 2005 10:27:00 GMT

射击游戏中跟踪弹及小角度移动的开发

作者:牛阿牛

2005-04-22

nhf_2008@hotmail.com

email:nhf20021166@163.com

留言:希望能给各位游戏开发一点的介绍;如有问题,请联系.

游戏射击中, 跟踪弹和定向弹应该是重要的设计点!

技术角度:动态改变自身方向属性，平滑移动.

艺术方面:动人的轨迹,平滑的移动.

此处将重点放在跟踪弹和小角度定向弹进行阐述.

小角度定向弹：

接近0度或90度的正弦余弦方向步长处理,本处采取,增加子弹的移动距离属性,这样我们就可以根据总移动长度来求x,y方向的移动,不会出现,x或y轴因为步长小而每次都为零的情况..

跟踪弹：

借鉴，有障碍追踪算法的思想；不过此处更简单的是，不考虑地形的因素，只需要将两个sprite ，确定为一个点而不是一个矩形；这样根据双方的位置，每次调整跟踪弹的方向即可。

其次，关于敌方多个目标的选择问题；我们可以自定义一个策略（优先选择策略，如：生命力小的，战斗力强的，sprite优先分类也行）；也可以根据可选择种类，随机选择目标进行跟踪，直到目标死掉，然后可以考虑选择新的目标，或者自动死亡模式。

对于，动态生成可选择范围，动态分配概率，动态随机选取思想在有障碍追逐算法的探讨一文中已经作了探讨。

射击游戏中弹幕的开发

牛阿牛-野狼穴 — Tue, 29 Mar 2005 06:35:00 GMT

射击游戏中弹幕的开发

作者:牛阿牛

2005-02-28

nhf_2008@hotmail.com

nhf_2003@hotmail.com

email:nhf20021166@163.com

留言:希望能给各位游戏开发一点的介绍;如有问题,请联系.

游戏射击中, boss可能是最重要的设计点!

技术角度:弹幕的组合,肢体的配合,动作的衔接.

艺术方面:绚丽的弹幕,新颖的运动,敏捷的反应.

 此处将重点放在boss的弹幕及其组合方面进行阐述.

追逐玩家的火龙,挥动的双钳,伸缩的双臂,总能给玩家更多新鲜感,更多的满足感!当然组合起来,就可能有更好的效果!

商家追求的是利润,策划追求的是艺术,玩家追求是满足!

我们是要将三位上帝的要求用技术来实现!

下面我们考虑一种实现方法

如果是强悍的boss,其弹幕一定很绚丽而又凶险,当然多变性是更重要的…

 此处首先说明的是,接近0度或90度的正弦余弦方向步长处理,本处采取,增加子弹的移动距离属性,这样我们就可以根据总移动长度来求x,y方向的移动,不会出现,x或y轴因为步长小而每次都为零的情况..

 我们此处也不再考虑,怎样加发射一个子弹,其实就是在链中添加一个子弹…,爆炸或者跑出屏幕,从链表中删除,链表操作,请参考链表处理一文….

子弹的数据结构:

typedef struct _CBullet ///暂作

{

 Sprite stSprite;

 int nDirx;

 int nDiry;

 DIR m_nDir; ////方向,8个方向….

 Point pDest; //目标点x,y的结构体

 Point pSour; //原始点

 BOOL bExplore; ////



 OBJSIZE m_nSize; //可以分为多个类型的.

 WEAPON m_nWeapon; ///武器类型了.武器的类型,主要在方向及威力,性能上起作用…

 BYTE m_nKillPow; ///杀伤力

 BYTE nIndex; ///某些状态的公用状态值

 BYTE nMoveDistance; //移动距离

 BYTE nAngle; //角度

 Explore MeExplore; ///暂不考虑

 Explore MapExplore; //暂不考虑

 PLAYERSTATUS m_nStatus; // 子弹状态

}BULLET;

通过数学函数处理:

 对每个子弹设定运行函数即可…

///////通过定时处理

1) 扇型弹幕的,可以设置速度,形成快慢两种了.

处理时定义临时变量,然后循环一定数目,每次添加子弹,当然根据方向,根据要求设置速度,,,这样就可形成扇型弹幕….

2) 螺旋型弹幕,如果每次添加的子弹时,闪开一定小角度,就可以形成块状扇型的….

通过boss里面的索引状态,然后每次重新设定起始角度,作扇型弹幕,即可,在多次定时器时即可实现螺旋型弹幕

3) 烟花型:原理类似,只要每次添加时,以公用索引角度添加,同时添加垂直和同线异向的子弹,定时器宣传,索引值变化,即可..

4) 鞭子型,,原理类似,每次只添加两个子弹,上下或者左右对称,在定时器中,修改公用索引值,在多次定时处理后,即实现鞭子型的子弹

5) 束型子弹:原理是,每次根据目标位置,确定一个角度范围,然后生成3或4(也随机也行)个角度范围内的子弹,定时器处理后既成为属性弹幕

6) 加激光,加敌人,就是很简单的了…..

7) 然后对上面的子弹搞一些组合,就会更加丰富

boss的弹幕有间歇,也有组合,这就要求对boss的状态进行处理

typedef enum _FIRESTATUS

{

 FIRESTATUS_PREPARE = 0, //准备阶段

 FIRESTATUS_FIRING = 1, //射击中

 FIRESTATUS_END = 2 //休闲中.

}FIRESTATUS;

至于弹幕的组合

typedef enum _FIRESTYLE

{

 FIRE_CIRCLEFAST = 0, //半圆形快速

 FIRE_CIRCLESLOW = 1 , //半圆形慢速.

 FIRE_CIRCLEBLOCK = 2 , //半园行块状.

 FIRE_BOUND = 3 , //束状问题了.

 FIRE_BLIM = 4 , //辫子行的.

 FIRE_FLAME = 5 , //烟花型的.

 FIRE_LASER = 6, //激光

 FIRE_ENEMY = 7, //加敌人,主要指小潜艇了.

 FIRE_BLOCK = 8, //块状三乱行的.

 FIRE_CIRCLEFASTSLOW = 9 ,//半圆形快慢型的.

 FIRE_CIRCLEBOUND = 10 , //半圆形夹杂束型的.

 FIRE_CIRCLELASER = 11 ,// 半圆形夹杂激光

 FIRE_CIRCLEENEMY = 12 , // 半圆形夹杂敌人的.

 FIRE_BLIMBOUND =13 ,// 辫子型夹杂束型的.

 FIRE_BLIMLASER = 14 ,// 辫子型夹杂激光

 FIRE_BLIMENEMY = 15 , // 辫子型夹杂敌人的.

 FIRE_FLAMEBOUND = 16 , //烟花型夹杂束型的.

 FIRE_FLAMELASER = 17, //烟花型夹杂激光的

 FIRE_FLAMEENEMY = 18 , //烟花型夹杂敌人

}FIRESTYLE;

///boss的射击,将根据状态,每个状态持续多少个周期,可以固定,也可以调节

这里的每一个细节都要细分处理,省略不得,什么部位发射什么弹幕,

不同的部位弹幕组合,请注意难度可以调节,保证高手可以闯过…

if((pPart->bExist ==FALSE)||(pPart->bDestroy==TRUE)||(pPart->bFire==FALSE))

 {

 return TRUE;

 }

 else

 {

 ///////

 if(objSize==OBJ_LARGE)

 {

 x = pMe->gBigBoss.BodyRect.x + pPart->BodyRect.x+ (pPart->BodyRect.dx>>2);

 y = pMe->gBigBoss.BodyRect.y + pPart->BodyRect.y+ (pPart->BodyRect.dy>>1);

 }

 else

 {

 x = pMe->gSmallBoss.BodyRect.x + pPart->BodyRect.x+ (pPart->BodyRect.dx>>2);

 y = pMe->gSmallBoss.BodyRect.y + pPart->BodyRect.y+ (pPart->BodyRect.dy>>1);

 }

 //////////////////////////////////////////

 if(pPart->firestatus == FIRESTATUS_FIRING )

 {

 //进行分情况处理了.ok?

 switch(pPart->firestyle)

 {

 case FIRE_CIRCLESLOW:

 //if()

 AddLeftCirCleEnemyBullet(pMe,x,y,75,0,30,1,Bullet_Speed_Slow,FALSE);

 break;

 case FIRE_LASER:

 AddEnemyLaserBullet(pMe,x,y,3);

 break;

 case FIRE_BOUND: //

 {

 nDir =GetDir(pMe,x,y);

 nAngle =Angle(pMe,x,y);

 AddBoundEnemyBullet(pMe,x,y,nDir,nAngle,1,7,0,Bullet_Speed_Slow);

 }

 break;

 case FIRE_CIRCLEFAST:

 AddLeftCirCleEnemyBullet(pMe,x,y,75,0,30,1,Bullet_Speed_Med,FALSE);

 break;

 case FIRE_BLIM:

 AddLimbEnemyBullet(pMe,x,y,(BYTE)(pPart->fireIndex<<1) ,2,Bullet_Speed_Slow);

 break;

 case FIRE_FLAME:

 AddFireEnemyBullet(pMe,x,y,(BYTE)(pPart->fireIndex) ,0, Bullet_Speed_Small);

 break;

 case FIRE_ENEMY:

 BossAddEnemy(pMe,x,y,OBJ_SMALLSUBMARINE,OBJ_SMALL);

 break;

 case FIRE_BLOCK: ///

 GETRAND(&rand,sizeof(unsigned char));

 if(rand&0x04)

 {

 AddLeftCirCleEnemyBullet(pMe,x,y,75,0,15,1,Bullet_Speed_Slow,FALSE);

 }

 else

 {

 AddLeftCirCleEnemyBullet(pMe,x,y,75,0,30,1,Bullet_Speed_Slow,FALSE);

 }

 break;

 case FIRE_CIRCLEFASTSLOW:

 if(pPart->fireIndex &0x0008)

 {

 AddLeftCirCleEnemyBullet(pMe,x,y,75,0,45,1,Bullet_Speed_Med,FALSE);

 }

 else

 {

 AddLeftCirCleEnemyBullet(pMe,x,y,75,0,30,1,Bullet_Speed_Slow,FALSE);

 }

 break;

 case FIRE_BLIMLASER:

 /*

 if(pPart->fireIndex &0x0008)

 {

 AddEnemyLaserBullet(pMe,x,y,3);

 }

 else

 {

 */

 AddLimbEnemyBullet(pMe,x,y,(BYTE)(pPart->fireIndex<<1) ,2,Bullet_Speed_Slow);

 //}



 break;

 case FIRE_CIRCLEBLOCK:

 AddLeftCirCleEnemyBullet(pMe,x,y,75,0,30,1,Bullet_Speed_Slow,TRUE);

 break;

 case FIRE_FLAMEBOUND:

 if(pPart->fireIndex &0x0008)

 {

 AddEnemyLaserBullet(pMe,x,y,3);

 }

 else//

 {

 AddFireEnemyBullet(pMe,x,y,(BYTE)(pPart->fireIndex) ,0, Bullet_Speed_Small);

 }



 break;

 }

 }

///具体的每一种弹幕添加原理,前面已经有了

/////////////////////////添加左向半圆子弹-包括块状

BOOL AddLeftCirCleEnemyBullet(FPSApp * pMe,int x,int y,BYTE nEnd,BYTE nStart,BYTE nStep,BYTE nIndex,BYTE nSpeed,BOOL bBlock)

{

 ////

 int nBegin = 0;

 BOOL bNormal = TRUE;///

 nBegin = nEnd;

 if(!bBlock)

 {

 while(nBegin >= nStart )

 {

 if(!AddEnemyBullet(pMe,WEAPON_ORANGE,x,y,DIR_LEFTUP,Cos(nBegin),Sin(nBegin),FALSE,nIndex,nSpeed,Bullet_Power))

 {

 bNormal=FALSE;

 break;

 }

 nBegin -= nStep;

 }

 //

 if(!AddEnemyBullet(pMe,WEAPON_ORANGE,x,y,DIR_LEFTUP,Cos(0),Sin(0),FALSE,nIndex,nSpeed,Bullet_Power))

 {

 bNormal=FALSE;

 }



 nBegin = nEnd;

 while(nBegin >=nStart )

 {

 if(!AddEnemyBullet(pMe,WEAPON_ORANGE,x,y,DIR_LEFTDOWN,Cos(nBegin),Sin(nBegin),FALSE,nIndex,nSpeed,Bullet_Power))

 {

 bNormal=FALSE;

 break;

 }

 nBegin -= nStep;

 }

 }

 else /////默认数据,步长2,数量4

 {

 while(nBegin >= nStart )

 {

 if(!AddBlockEnemyBullet(pMe,x,y,DIR_LEFTUP,(BYTE)nBegin,2,4,nIndex,nSpeed))

 {

 bNormal=FALSE;

 break;

 }

 nBegin -= nStep;

 }

 //

 if(!AddBlockEnemyBullet(pMe,x,y,DIR_LEFTUP,0,2,4,nIndex,nSpeed))

 {

 bNormal=FALSE;

 }



 nBegin = nEnd;

 while(nBegin >=nStart )

 {

 if(!AddBlockEnemyBullet(pMe,x,y,DIR_LEFTUP,(BYTE)nBegin,2,4,nIndex,nSpeed))

 {

 bNormal=FALSE;

 break;

 }

 nBegin -= nStep;

 }

 }



 return bNormal;

}

//////////////添加块状子弹,不是半圆,只是其中的一个单元

BOOL AddBlockEnemyBullet(FPSApp * pMe,int x,int y,DIR nDir,BYTE nStart,BYTE nStep,BYTE nCount,BYTE nIndex,BYTE nSpeed)

{

 //switch

 BOOL bNormal = TRUE;///

 BYTE nNum = 0;

 BYTE nBegin = nStart;

 BOOL bChangeDir = FALSE;

 DIR nRealDir = nDir; /////

 while(nNum<nCount)

 {

 /////

 if(!AddEnemyBullet(pMe,WEAPON_ORANGE,x,y,nRealDir,Cos(nBegin),Sin(nBegin),FALSE,nIndex,nSpeed,Bullet_Power))

 {

 bNormal=FALSE;

 break;

 }

 ////////////////////

 if(nDir==DIR_LEFTUP)

 {

 if(nBegin+ nStep>=90)

 {

 break;

 }

 else

 nBegin+=nStep;

 }

 else

 {

 if(bChangeDir==TRUE)

 {

 ///////////

 nBegin+=nStep;

 }

 else

 {

 if(nBegin < nStep)

 {

 bChangeDir = TRUE;

 nRealDir= DIR_LEFTUP;

 nBegin = nStep - nBegin;

 }

 else

 {

 nBegin -= nStep;

 }

 }

 }

 nNum++;

 }

 return bNormal;

}/////////

////////添加束型子弹

BOOL AddBoundEnemyBullet(FPSApp * pMe,int x,int y,DIR nDir,BYTE nStart,BYTE nStep,BYTE nCount,BYTE nIndex,BYTE nSpeed)//添加一束一束的子弹

{

 //////////////////////////////////////

 BOOL bNormal =TRUE;

 BYTE nTempAngle =0;

 BYTE nCountNum =0 ;

 /////左三,右三,角度根据nStep 来定吧.

 //自身添加了啊.

 if(!AddEnemyBullet(pMe,WEAPON_ORANGE,x,y,nDir,Cos(nStart),Sin(nStart),FALSE,nIndex,nSpeed,Bullet_Power))

 {

 bNormal =FALSE;

 }

 nTempAngle = nStart;

 nTempAngle += nStep;

 nCountNum=0;

 while(nTempAngle<=90)

 {

 if(nCountNum>=3)

 break;

 if(!AddEnemyBullet(pMe,WEAPON_ORANGE,x,y,nDir,Cos(nStart),Sin(nStart),FALSE,nIndex,nSpeed,Bullet_Power))

 {

 bNormal =FALSE;

 break;

 }

 nCountNum++;

 nTempAngle += nStep;

 }

 nTempAngle = nStart;

 nTempAngle -= nStep;

 nCountNum=0;

 while(nTempAngle>=0)

 {

 if(nCountNum>=3)

 break;

 if(!AddEnemyBullet(pMe,WEAPON_ORANGE,x,y,nDir,Cos(nStart),Sin(nStart),FALSE,nIndex,nSpeed,Bullet_Power))

 {

 bNormal =FALSE;

 break;

 }

 nCountNum++;

 nTempAngle -= nStep;

 }

 /////

 return bNormal;

}

////添加鞭子型子弹

BOOL AddLimbEnemyBullet(FPSApp * pMe,int x,int y,BYTE nAngle,BYTE nIndex,BYTE nSpeed)//辫子型的子弹

{

 BOOL bNormal =TRUE;



 if(nAngle>180)

 nAngle= 180;

 ////////

 if(nAngle>90)

 {

 //////

 if(!AddEnemyBullet(pMe,WEAPON_ORANGE,x,y,DIR_LEFTUP,Cos(180-nAngle),Sin(180-nAngle),FALSE,nIndex,nSpeed,Bullet_Power))

 {

 bNormal =FALSE;

 }

 if(!AddEnemyBullet(pMe,WEAPON_ORANGE,x,y,DIR_LEFTDOWN,Cos(180-nAngle),Sin(180-nAngle),FALSE,nIndex,nSpeed,Bullet_Power))

 {

 bNormal =FALSE;

 }

 }

 else

 {

 //////

 if(!AddEnemyBullet(pMe,WEAPON_ORANGE,x,y,DIR_RIGHTUP,Cos(nAngle),Sin(nAngle),FALSE,nIndex,nSpeed,Bullet_Power))

 {

 bNormal =FALSE;

 }

 if(!AddEnemyBullet(pMe,WEAPON_ORANGE,x,y,DIR_RIGHTDOWN,Cos(nAngle),Sin(nAngle),FALSE,nIndex,nSpeed,Bullet_Power))

 {

 bNormal =FALSE;

 }

 }

 return bNormal;

}

////////添加螺旋型单元子弹

BOOL AddFireEnemyBullet(FPSApp * pMe,int x,int y,BYTE nStart,BYTE nIndex,BYTE nSpeed)//

{

 BOOL bNormal =TRUE;

 if(!AddEnemyBullet(pMe,WEAPON_ORANGE,x,y,DIR_LEFTUP,Cos(nStart),Sin(nStart),FALSE,nIndex,nSpeed,Bullet_Power))

 {

 bNormal =FALSE;

 }

 if(!AddEnemyBullet(pMe,WEAPON_ORANGE,x,y,DIR_RIGHTUP,Cos(90-nStart),Sin(90-nStart),FALSE,nIndex,nSpeed,Bullet_Power))

 {

 bNormal =FALSE;

 }

 /////

 if(!AddEnemyBullet(pMe,WEAPON_ORANGE,x,y,DIR_RIGHTDOWN,Cos(nStart),Sin(nStart),FALSE,nIndex,nSpeed,Bullet_Power))

 {

 bNormal =FALSE;

 }

 /////

 if(!AddEnemyBullet(pMe,WEAPON_ORANGE,x,y,DIR_LEFTDOWN,Cos(90-nStart),Sin(90-nStart),FALSE,nIndex,nSpeed,Bullet_Power))

 {

 bNormal =FALSE;

 }

 return bNormal;

}

///添加激光子弹

BOOL AddEnemyLaserBullet(FPSApp * pMe,int x,int y,BYTE nCount)

{

 BOOL bNormal = FALSE;

 switch(nCount)

 {

 case 1:

 {

 if(!AddEnemyBullet(pMe,WEAPON_LASER,x,y,DIR_LEFTDOWN,Cos(0),Sin(0),FALSE,0,Bullet_Speed_Med,Bullet_Power))

 {

 bNormal =FALSE;

 }

 }

 break;

 case 2:

 {

 if(!AddEnemyBullet(pMe,WEAPON_LASER,x-CELL_W,y-8,DIR_LEFTDOWN,Cos(0),Sin(0),FALSE,0,Bullet_Speed_Med,Bullet_Power))

 {

 bNormal =FALSE;

 }

 if(!AddEnemyBullet(pMe,WEAPON_LASER,x-CELL_W,y+8,DIR_LEFTDOWN,Cos(0),Sin(0),FALSE,0,Bullet_Speed_Med,Bullet_Power))

 {

 bNormal =FALSE;

 }

 }

 break;

 case 3:

 if(!AddEnemyBullet(pMe,WEAPON_LASER,x-CELL_W,y-CELL_H,DIR_LEFT,Cos(0),Sin(0),FALSE,0,Bullet_Speed_Med,Bullet_Power))

 {

 bNormal =FALSE;

 }

 if(!AddEnemyBullet(pMe,WEAPON_LASER,x-CELL_W,y,DIR_LEFT,Cos(0),Sin(0),FALSE,0,Bullet_Speed_Med,Bullet_Power))

 {

 bNormal =FALSE;

 }

 if(!AddEnemyBullet(pMe,WEAPON_LASER,x-CELL_W,y+CELL_H,DIR_LEFT,Cos(0),Sin(0),FALSE,0,Bullet_Speed_Med,Bullet_Power))

 {

 bNormal =FALSE;

 }

 break;

 }

 return bNormal;

}

////////////////////////添加自杀式敌人,此处小潜艇而已

BOOL BossAddEnemy(FPSApp * pMe,int x,int y,OBJECT obj,OBJSIZE size)

{

 BOOL bNormal = FALSE;

 if(!AddSubMarine(pMe,OBJ_SMALL,y-8))

 {

 bNormal = FALSE;

 }

 /////

 if(y+CELL_H< pMe->stWorldRect.dy-CELL_H)

 {

 if(!AddSubMarine(pMe,OBJ_SMALL,y+CELL_H-8))

 {

 bNormal = FALSE;

 }

 }

 if(y-CELL_H< 48)

 {

 if(!AddSubMarine(pMe,OBJ_SMALL,y-CELL_H-8))

 {

 bNormal = FALSE;

 }

 }

 return bNormal;

}

平面游戏中龙状sprite的开发

牛阿牛-野狼穴 — Tue, 29 Mar 2005 05:40:00 GMT

平面游戏中龙状sprite的开发

作者:牛阿牛

2005-02-28

nhf_2008@hotmail.com

nhf_2003@hotmail.com

email:nhf20021166@163.com

留言:希望能给各位游戏开发一点的介绍;如有问题,请联系.

游戏射击中, boss可能是最重要的设计点!

技术角度:弹幕的组合,肢体的配合,动作的衔接.

艺术方面:绚丽的弹幕,新颖的运动,敏捷的反应.

此处将重点放在boss的肢体及动作方面进行阐述.

追逐玩家的火龙,挥动的双钳,伸缩的双臂,总能给玩家更多新鲜感,更多的满足感!当然组合起来,就可能有更好的效果!

商家追求的是利润,策划追求的是艺术,玩家追求是满足!

我们是要将三位上帝的要求用技术来实现!

下面我们考虑一种实现方法

如果是一条火龙,它子弹的问题不作考虑;我们只作肢体的运动考虑

首先建立数据结构,例如:

typedef struct _CPart

{

AEERect BodyRect; ///相对中心的

BOOL bCanFire;

BOOL bDead;

BOOL bKeyBody; //是否是主体body

Int nLife;

PARTSTYLE whichpart; ///什么部位,只需要知道是哪个部位的梅举类型

}CPart;

typedef struct _CHand

{

CPart part[MAX_HANDCELL_NUM]; //////

BOOL bExist; ////便于定义数据结构

HANDSTYLE handStyle; //运动方式,如伸缩,回笼等

FIRESTYLE firestyle ; //什么弹幕还是什么子弹

BYTE nIndex; ///主要用于移动了.

}HAND;

typedef struct _CDragon

{

CPart part[MAX_HANDCELL_NUM]; //////

BOOL bExist; ////便于定义数据结构

HANDSTYLE handStyle; //运动方式,追逐等

BYTE nIndex; ///主要用于移动了.

}HAND;

这里只作简单的思想介绍,功能完备的话可以将此思想延伸即可…

此处的数组可以搞成链表甚或动态地图编辑都可以的….,

那么根据数据结构的处理,作相应的算法处理…

//膨胀检测,需要循环检测每一部分,同样根据不同的属性显示不同的图形(图形算法处理)即可实现打死打掉的动态惨象感,同样根据属性,看看是否打子弹等作用…

肢体的运动: ///基本通过定时器处理了…

伸缩:///先根据顺序把每个单元拉出来,当然第一次只拉动0,第二次0,1……

if(pMe->gBigBoss.LeftHand.handStyle ==HAND_PROTRUDE)

{

//先处理吧.

if(pMe->gBigBoss.LeftHand.nIndex < MED_HANDCELL_NUM-1 )

{

for(i=0;i<pMe->gBigBoss.LeftHand.nIndex+1;i++)

{

pMe->gBigBoss.LeftHand.BodyRect[i].x = pMe->gBigBoss.LeftHand.BodyRect[MED_HANDCELL_NUM-1].x-pMe->HandOffSet[pMe->gBigBoss.LeftHand.nIndex-i].x;

pMe->gBigBoss.LeftHand.BodyRect[i].y = pMe->gBigBoss.LeftHand.BodyRect[MED_HANDCELL_NUM-1].y+pMe->HandOffSet[pMe->gBigBoss.LeftHand.nIndex-i].y;

pMe->gBigBoss.RightHand.BodyRect[i].x = pMe->gBigBoss.RightHand.BodyRect[MED_HANDCELL_NUM-1].x-pMe->HandOffSet[pMe->gBigBoss.LeftHand.nIndex-i].x;

pMe->gBigBoss.RightHand.BodyRect[i].y = pMe->gBigBoss.RightHand.BodyRect[MED_HANDCELL_NUM-1].y-pMe->HandOffSet[pMe->gBigBoss.LeftHand.nIndex-i].y;

// DBGPRINTF("%d,%d,%d",pMe->gBigBoss.LeftHand.BodyRect[i].x,pMe->gBigBoss.LeftHand.BodyRect[i].y,i);

// DBGPRINTF("%d,%d,%d",pMe->gBigBoss.RightHand.BodyRect[i].x,pMe->gBigBoss.RightHand.BodyRect[i].y,i);

}

// DBGPRINTF("over");

pMe->gBigBoss.LeftHand.nIndex++;

}

else

{

pMe->gBigBoss.LeftHand.nIndex = 0 ;

pMe->gBigBoss.LeftHand.handStyle = HAND_GRIP;

}

围住:///根据,需要,模拟前双臂向中间交叉,最外面的每次移动幅度最大,一次减小而已…..

if(pMe->gBigBoss.LeftHand.handStyle ==HAND_GRIP)

{

//先处理吧.

if(pMe->gBigBoss.LeftHand.nIndex < MAX_GRIP_TIMES )

{

for(i=0;i<pMe->gBigBoss.LeftHand.nIndex+1;i++)

{

//pMe->gBigBoss.LeftHand.BodyRect[i].x = pMe->gBigBoss.LeftHand.BodyRect[0].x-pMe->HandOffSet[i].x;

pMe->gBigBoss.LeftHand.BodyRect[i].y -= (MED_HANDCELL_NUM-1 - i);

//pMe->gBigBoss.RightHand.BodyRect[i].x = pMe->gBigBoss.RightHand.BodyRect[0].x-pMe->HandOffSet[i].x;

pMe->gBigBoss.RightHand.BodyRect[i].y += (MED_HANDCELL_NUM-1 - i);

}

pMe->gBigBoss.LeftHand.nIndex++;

//DBGPRINTF("%d,%d",pMe->gBigBoss.LeftHand.BodyRect[0].x,pMe->gBigBoss.LeftHand.BodyRect[0].y);

}

else

{

pMe->gBigBoss.LeftHand.nIndex = 0 ;

pMe->gBigBoss.LeftHand.handStyle = HAND_RETRACT;

}

回笼: ///逐次的将索引处坐标覆盖覆盖前面的全部坐标

If(pMe->gBigBoss.LeftHand.handStyle ==HAND_RETRACT)

{

//先处理吧.

if(pMe->gBigBoss.LeftHand.nIndex < MED_HANDCELL_NUM-1 )

{

////

for(i=0;i<pMe->gBigBoss.LeftHand.nIndex+1;i++)

{

pMe->gBigBoss.LeftHand.BodyRect[i].x = pMe->gBigBoss.LeftHand.BodyRect[i+1].x ;

pMe->gBigBoss.LeftHand.BodyRect[i].y = pMe->gBigBoss.LeftHand.BodyRect[i+1].y;

pMe->gBigBoss.RightHand.BodyRect[i].x = pMe->gBigBoss.RightHand.BodyRect[i+1].x;

pMe->gBigBoss.RightHand.BodyRect[i].y = pMe->gBigBoss.RightHand.BodyRect[i+1].y;

}

pMe->gBigBoss.LeftHand.nIndex++;

//DBGPRINTF("%d,%d",pMe->gBigBoss.LeftHand.BodyRect[0].x,pMe->gBigBoss.LeftHand.BodyRect[0].y);

}

else

{

pMe->gBigBoss.LeftHand.nIndex = 0 ;

pMe->gBigBoss.LeftHand.handStyle = HAND_PROTRUDE;

}

追逐: //逆序将坐标赋给前一位,

/// for(i=0;i<MAX_HANDCELL_NUM-1;i++)

{

pMe->gBigBoss.LeftHand.BodyRect[MAX_HANDCELL_NUM-i-1].x = pMe->gBigBoss.LeftHand.BodyRect[MAX_HANDCELL_NUM-i-2].x;

pMe->gBigBoss.LeftHand.BodyRect[MAX_HANDCELL_NUM-i-1].y = pMe->gBigBoss.LeftHand.BodyRect[MAX_HANDCELL_NUM-i-2].y;

pMe->gBigBoss.RightHand.BodyRect[MAX_HANDCELL_NUM-i-1].x = pMe->gBigBoss.RightHand.BodyRect[MAX_HANDCELL_NUM-i-2].x;

pMe->gBigBoss.RightHand.BodyRect[MAX_HANDCELL_NUM-i-1].y = pMe->gBigBoss.RightHand.BodyRect[MAX_HANDCELL_NUM-i-2].y;

}

///////////////然后根据目标的位置,进行处理,将最初的节点向目标靠近一个步长即可…

其他的更简单的动作,此处不作说明……

如果你觉得这么简单就可以实现那些效果不可相信的话,试试即可…
如下图中3图

软件开发和设计思想

21世纪合格人才必备7大技能 zt

使用Jbulider开发j2me程序 zt 作者：syngle 文章来源：原创 点击数：1844 更新时间：2005-1-12

何苦编程

完美的软件项目开发团队结构（来自微软） zt

射击游戏中跟踪弹及小角度移动的开发

射击游戏中弹幕的开发

平面游戏中龙状sprite的开发

使用Jbulider开发j2me程序 zt 作者：syngle 文章来源：原创点击数：1844 更新时间：2005-1-12