Flash实例教程100例

//缓动类不在flash包中在fl包中所以要先导入 import fl.transitions.Tween;//导入缓动类

import fl.transitions.TweenEvent;//导入缓动事件

import fl.transitions.easing.Regular;//导入缓动效果中有规律的 var arrTupian:Array=[];//存放图片的数组

var tweenscaleX:Tween;//用来控制图片宽高的缓动类 var tweenscaleY:Tween; var datu:MovieClip;

for (var i:int=0; i<8; i++) {

var xiaotu:MovieClip =new Pic();//这里Pic是库中一个存放图片的类文件 addChild(xiaotu);

xiaotu.gotoAndStop(i+1); xiaotu.width=120; xiaotu.height=100;

xiaotu.x=xiaotu.width/2+i*(xiaotu.width+10); xiaotu.y=420;

arrTupian.push(xiaotu);

xiaotu.addEventListener(Event.ENTER_FRAME ,dongf);//为每个小球添加移动帧频函数 }

function dongf(e) { var mc:MovieClip=e.target; mc.x-=6;

if (mc.x<0-(xiaotu.width/2+10)) {//如果该图片出了场景则放在最后一张图片的位置

mc.x=xiaotu.width/2+7*(xiaotu.width+10); }

mc.buttonMode=true;

mc.addEventListener(MouseEvent.MOUSE_OVER ,overf);///鼠标移过时候停止移动 mc.addEventListener(MouseEvent.MOUSE_OUT,outf);// }

function overf(e) {

for (i=0; i//注意是点击一张图片应该让所有的图片都移除移动的侦听 arrTupian[i].removeEventListener(Event.ENTER_FRAME ,dongf);

arrTupian[i].removeEventListener(MouseEvent.MOUSE_OVER ,overf);

//注意也要把移过函数移除，等下次再调用再添加防止下面的效果还没有达到又开始此函数 }

//此时大图出现 datu=new Pic();

datu.gotoAndStop(arrTupian.indexOf (e.target)+1); addChild(datu);

datu.x=stage.stageWidth/2; datu.y=200;

tweenscaleX=new Tween(datu,\"scaleX\参数从1倍扩大到3倍

tweenscaleY=new Tween(datu,\"scaleY\

//参数分别是对象，属性，缓动类型，开始参数，结束参数，缓动事件，true表示为单位为妙false表示为帧 }

function outf(e) {

e.target.removeEventListener(MouseEvent.MOUSE_OVER ,overf); e.target.removeEventListener(MouseEvent.MOUSE_OVER ,outf); tweenscaleX=new Tween(datu,\"scaleX\开始和结束的参数反过来则实现了缩小的效果

tweenscaleY=new Tween(datu,\"scaleY\

//tweenScaleX=new Tween.yoyo ()或者用这个方法，表示实现原来缓动的相反过程 //tweenScaleY=new Tween.yoyo ()

tweenscaleX.addEventListener(TweenEvent.MOTION_FINISH,fishf); }

function fishf(e) { removeChild(datu);

datu=null;//注意从显示列表中清除后，

//元件本身还有东西，因此还要把大图元件清空 for (i=0; iarrTupian[i].addEventListener(Event.ENTER_FRAME ,dongf); }

实例二 利用timer类实现图片的切换

场景中有一个pic图片多帧元件，currnum和totalnum两个动态文本speed输入文本，一个msg动态文本

var timer:Timer;

speed.text=\"2\"//播放的初始速度为1000毫秒 btn.addEventListener(MouseEvent.CLICK ,f); function f(e) { msg.text=\"\"

timer=new Timer(1000*Number(speed.text),pic.totalFrames);

//计时器运行的时间单位都是毫秒，因此输入的速度都是秒应该再乘以1000. //输入的文本都是字符串因此要转化成数字 timer.start();

timer.addEventListener(TimerEvent.TIMER ,timerf);

timer.addEventListener (TimerEvent.TIMER_COMPLETE,comf)//添加一个播放完后的函数 }

function timerf(e) {

pic.gotoAndStop(timer.currentCount);//图片播放的张数及为计时器运行的当前次数

//例如运行一次既是第一张，两次则为第二张 currnum.text=String(timer.currentCount);

totalnum.text=String(timer.repeatCount);//计时器总共运行的次数 }

function comf(e){

msg.text=\"图片已经播放完毕谢谢欣赏\"//信息文本框的文本显示内容 }

var format:TextFormat=new TextFormat(\"Impact\ var txt:TextField=new TextField(); addChildAt(txt,numChildren-1); txt.text=\"这里随便写些东西\"; txt.wordWrap=true;

txt.setTextFormat(format); txt.width=txt.textWidth; txt.height=txt.textHeight; txt.x=10,txt.y=33;

实例三 点击小图看大图效果

var targetArr:Array=[]; var pointArr:Array=[]; var picArr:Array=[]; var index:int;

var targetPoint=new Point(275,200); for (var i:int=0; i<20; i++) { var point:Point=new Point(); var targetP:Point=new Point();

//var C:Class=getDefinitionByName(\"cat\"+i) as Class;/加载同路径文件夹中的名字为cat+i20张的图片

var bmd:BitmapData=new C(0,0);//库中一个图片类文件 var bmp:Bitmap=new Bitmap(bmd); var mc:MovieClip=new MovieClip(); addChild(mc);

mc.addChild(bmp);

bmp.x=- bmp.width/2; bmp.y=- bmp.height/2; mc.scaleX=mc.scaleY=.4;

i<6?(mc.x=2.5+mc.width/2+i*(mc.width+10),mc.y=mc.height/2):0;//上面六个图片的位置,坐标为图片的中心

i>=6&&i<10?(mc.x=550-mc.width/2-2.5,mc.y=mc.height/2+mc.height+8+(i-6)*(mc.height+8)):0;//右边四张图片的坐标

i>=10&&i<16?(mc.x=550-mc.width/2-2.5-(i-10)*(mc.width+10),mc.y=400-mc.height/2):0;//下面六张图片坐标

i>=16&&i<20?(mc.x=mc.width/2+2.5,mc.y=400-mc.height/2-mc.height-8-(i-16)*(mc.height+8)):0;//左边四张图片的坐标

point.x=targetP.x=mc.x,point.y=targetP.y=mc.y;//记录此时每张图片的位置 mc.mouseChildren=false;

mc.n=i;//定义mc的私有属性记录每张图片的索引值 picArr.push(mc);//

targetArr.push(targetP); pointArr.push(point); }

var timer:Timer=new Timer(1000);

timer.start();

timer.addEventListener(TimerEvent.TIMER,picMove); var k:int=0;

function picMove(e) {//图片移动效果 k++;

for (var j:int=0; jtargetArr[j].x=pointArr[(k+j)%pointArr.length].x;//当前点的坐标随着k的增加等于目标点坐标循环变换

targetArr[j].y=pointArr[(k+j)%pointArr.length].y;

if (picArr[j].x==275&&picArr[j].y==200) {//说明是中心位置的图片 continue;

} else {//说明是周围的图片

picArr[j].x=pointArr[(k+j)%pointArr.length].x;//让每张图片的坐标循环变换 picArr[j].y=pointArr[(k+j)%pointArr.length].y; } } }

for (i=0; ipicArr[i].addEventListener(MouseEvent.CLICK,clickF); }

function clickF(e) {

setChildIndex(e.target,numChildren-2);//先把当前被点击的图片放在第二层 objMove(e.target,targetPoint,1,1);

if (picArr[index].x==275,picArr[index].y==200) { objMove(picArr[index],targetArr[index],.15,.15); }

index=e.target.n; }

function

objMove(displayObject:DisplayObject,targetObj:Point,targetScalex:Number,targetScaley:Number) {

///**/参数分别是当前对象，当前点 ，x方向的缩放值，y方向上的缩放值 timer.stop();//先让计时器停止，即点击图片动画过程中让图片移动的事件停止 displayObject.addEventListener(Event.ENTER_FRAME,frame); function frame(e) {

for (var i:int=0; ipicArr[i].removeEventListener(MouseEvent.CLICK,clickF);// 点击每张图片后马上先移除点击事件 }

e.target.x+=(targetObj.x-e.target.x)/5;//缓动公式实现缓动效果 e.target.y+=(targetObj.y-e.target.y)/5;

e.target.scaleX+=(targetScalex-e.target.scaleX)/5; e.target.scaleY+=(targetScaley-e.target.scaleY)/5; var

dis:Number=Math.sqrt((targetObj.x-e.target.x)*(targetObj.x-e.target.x)+(targetObj.y-e.target.y)*(targetObj.y-e.target.y));

if (Math.abs(dis)<1) {//目标点和当前点的距离 e.target.x=targetObj.x; e.target.y=targetObj.y;

displayObject.removeEventListener(Event.ENTER_FRAME,frame);//图片达到目标点后移除该帧频事件 trace(\"ok\");

for (i=0; itimer.start();//计时器开始运行，即周围图片继续移动 } } }

var sp:Sprite=new Sprite();//画相框 addChild(sp); sp.x=275; sp.y=200;

sp.graphics.lineStyle(15,0xb66700);

sp.graphics.drawRect(-174,-124,348,248); sp.graphics.lineStyle(2,0xa95401);

sp.graphics.drawRoundRect(-177,-127,354,254,10,10); sp.graphics.lineStyle(3,0xa95401);

sp.graphics.drawRoundRect(-173,-123,346,246,10,10); sp.graphics.lineStyle(1.5,0xa95401); sp.graphics.moveTo(-178,-128); sp.graphics.lineTo(-168,-118); sp.graphics.moveTo(178,-128); sp.graphics.lineTo(168,-118); sp.graphics.moveTo(178,128); sp.graphics.lineTo(168,118); sp.graphics.moveTo(-178,128); sp.graphics.lineTo(-168,118);

sp.filters=[new BevelFilter(3,45,0xff9900,1,0x660000,1,5,5,1,3),new DropShadowFilter(4,45,0,1,5,5,.5,3)]; //=======

var format:TextFormat=new TextFormat(\"Impact\var txt:TextField=new TextField(); addChildAt(txt,numChildren-1); txt.text=\"这里随便写些东西\"; txt.wordWrap=true;

txt.setTextFormat(format); txt.width=txt.textWidth; txt.height=txt.textHeight; txt.x=10,txt.y=33;

实例四 条形遮罩

const W:Number=stage.stageWidth; const H:Number=stage.stageHeight;

var picSpr:Sprite=addChild(new Sprite()) as Sprite;//用来装矩形条的容器 var pic1:MovieClip = picSpr.addChild(new Pic()) as MovieClip;//实例化两个图集

var pic2:MovieClip = picSpr.addChild(new Pic()) as MovieClip; var maskSpr:Sprite=picSpr.addChild(new Sprite()) as Sprite;

pic2.gotoAndStop(3);//因为遮罩另一个图集所以先把另一个跳转到第二帧 pic2.mask=maskSpr;//矩形条容器遮罩图集二 //=====画矩形条函数

function Rect(w:Number,h:Number):Sprite {

var rect:Sprite = maskSpr.addChild(new Sprite()) as Sprite; rect.graphics.beginFill(0);

rect.graphics.drawRect(0,0,w,h); rect.graphics.endFill(); return rect; }

var num:uint=80;//矩形条的总条数 var rw:Number=W/num;//竖条的宽度 var rh:Number=H/num;//横条的宽度

var n:uint=0;//用来控制矩形的条数变化

var bl:Boolean=true;//用来控制矩形条的偶数情况和奇数情况 var a:uint=4*Math.random();//矩形条的从四种不同方向出现

var timerA:Timer=new Timer(40,80);//控制每一个矩形条出现的时间，共执行八十次 var timerB:Timer=new Timer(3000,1);//用来控制每一个效果完成后间隔的时间 timerA.start();

timerA.addEventListener(TimerEvent.TIMER,ttA); function ttA(evt:TimerEvent):void {

var rectH:Sprite=Rect(rw,H);//实例化竖条 var rectW:Sprite=Rect(W,rh);//实例化横条 switch (a) { case 0 :

if (bl==true) {//当为真时，出现奇数条第一种效果从左上角出现

rectH.x=2*n*rw;//横坐标以竖条的宽度2倍增加即每隔一个宽度增加一个 rectW.y=2*n*rh;//同上

2*n==num-2?[n=0,bl=false]:0;//当n增加到最大值时，变为逆向出现偶竖条 }else{

rectH.x=W-(2*n-1)*rw; rectW.y=H-(2*n-1)*rh; }

break; case 1 :

if (bl==true) {//第二种效果从右下角出现 rectH.x=W-(2*n+1)*rw;// rectW.y=H-(2*n+1)*rh;

2*n==num-2?[n=0,bl=false]:0; } else {

rectH.x=(2*n-1)*rw; rectW.y=(2*n-1)*rh; }

break; case 2 :

if (bl==true) {//第三种效果从左下角出现 rectH.x=2*n*rw;

rectW.y=H-(2*n+1)*rh;

2*n==num-2?[n=0,bl=false]:0; } else {

rectH.x=W-(2*n-1)*rw; rectW.y=2*(n-1)*rh; }

break; default :

if (bl==true) {//第四种效果从右上角出现 rectH.x=W-(2*n+1)*rw; rectW.y=2*n*rh;

2*n==num-2?[n=0,bl=false]:0; } else {

rectH.x=2*(n-1)*rw; rectW.y=H-(2*n-1)*rh; } } n++;

if (timerA.currentCount==timerA.repeatCount) {//如果当前执行次数等于总次数说明已经完成了实例化的80条矩形条

for (var i:uint=maskSpr.numChildren; i>0; i--) {//就删除所有的矩形条 maskSpr.removeChildAt(0); }

pic1.currentFrame==pic1.totalFrames?pic1.gotoAndStop(1):pic1.nextFrame();//图片集播放到末尾循环从头开始

pic2.currentFrame==pic2.totalFrames?pic2.gotoAndStop(1):pic2.nextFrame(); timerB.start();//添加第二个时间侦听器间隔时间为3秒 } }

timerB.addEventListener(TimerEvent.TIMER,ttB); function ttB(evt:TimerEvent):void { a=4*Math.random(); n=0; bl=true;

timerA.reset(); timerA.start(); }

var sound:Sound=new Sound(new

URLRequest(\"http://bbs.kuailel.com/yinle/%D4%C6%C9%CF%C7%E0%C9%BD.mp3\")); var soundChannel:SoundChannel=new SoundChannel(); var bool:Boolean=true;

btn.addEventListener(MouseEvent.CLICK,ck); function ck(evt:MouseEvent):void { if (bool==true) { timerA.start();

soundChannel=sound.play(); btn.gotoAndStop(2); } else {

for (var i:uint=maskSpr.numChildren; i>0; i--) { maskSpr.removeChildAt(0); } n=0; bl=true;

a=4*Math.random(); timerA.reset(); timerA.stop(); timerB.stop();

soundChannel.stop(); btn.gotoAndStop(1); }

bool=! bool;}

addChildAt(btn,numChildren-1); addChildAt(bt,numChildren-1)

实例五 3d旋转效果

var num:Number=25;//照片的张数 var quanshu:int=2;//螺旋的圈数 var r:Number=300;//螺旋的半径

var ang:Number =(Math.PI *2*quanshu)/num;

//每张图片的角度，因为总共两圈所以总共的角度就360*2再除以总共张数 var con:Sprite;//图片容器

var arr:Array =new Array();//数组用来排序

root.transform.perspectiveProjection.fieldOfView=60; //场景时间轴的视角设置为60

root.transform.perspectiveProjection.projectionCenter=new Point(275,350); //主场景的消失点为舞台中心 con=new Sprite(); addChild(con); con.x=0; con.y=0; con.z=400;

for (var i=0; imc.rotationY=- i*ang*180/Math.PI+90;//通过旋转达到每张图片都面向y轴 mc.y=i*30-100; //arr.push(mc);}

addEventListener(Event.ENTER_FRAME ,f); function f(e) { con.rotationY+=2;

for (var j=0; jarr.push({mcc:con.getChildAt(j),Z:con.getChildAt(j).transform.getRelativeMatrix3D(root).position.z}); }

for (var i:int; iarr.sortOn(\"Z\坐标排序 con.addChildAt(arr[i].mcc,i); } }

实例六 简单的点小图出大图效果

for (var i:int=0; i<3; i++) {//把九张图片按照3×3格式排列 for (var j:int=0; j<3; j++) {

var mc:Mc=new Mc();//添加库中图片类文件 mc.gotoAndStop(i+1+j*3);

mc.width=mc.oldWidth=550/3;//设置宽为场景宽550三分之一 mc.height=mc.oldHeight=400/3; //设置高为场景高400三分之一 mc.flag=false;//定义一个mc的布尔值初始值为假即小图片时候 addChild(mc);

mc.x=mc.oldx=i*mc.width;//设置每张图片的坐标 mc.y=mc.oldy=j*mc.height;

mc.addEventListener(MouseEvent.MOUSE_DOWN ,f);}}//给每张图片添加点击事件 function f(e) { var mc=e.target;

setChildIndex(mc,numChildren-1);

mc.flag=!mc.flag;//布尔值取反值为真说明此时已经点击过变成大图 if (mc.flag) {//如果为真

mc.removeEventListener(Event.ENTER_FRAME ,loop2);//移除缩小事件 mc.addEventListener(Event.ENTER_FRAME ,loop1);//添加扩大事件

} else {//如果为假

mc.removeEventListener(Event.ENTER_FRAME ,loop1);//移除扩大 mc.addEventListener(Event.ENTER_FRAME ,loop2);}}//添加缩小 function loop1(e) {// var mc=e.target;

mc.x+=(0-mc.x)/5;//因为每张图片的注册点在左上角，所以目缓动目标位置（0,0）即把每张图片的左上角顶点移向场景左上角 mc.y+=(0-mc.y)/5;

mc.width+=(550-mc.width)/5;//并且同时宽高扩大缓动过程 mc.height+=(400-mc.height)/5; }

function loop2(e) {// var mc=e.target;

mc.x+=(mc.oldx-mc.x)/5;//回到原始位置， mc.y+=(mc.oldy-mc.y)/5;

mc.width+=(mc.oldWidth-mc.width)/5;//同时缩小到原来的大小 mc.height+=(mc.oldHeight-mc.height)/5; }

实例七 利用缓动类实现图片切换效果

import fl.transitions.Tween;//导入tween类 import fl.transitions.easing.*;//导入缓动类 var arr:Array=[];

function loaderpic(scale:Number ,i:int ,b:Boolean=false ):MovieClip { var mc:MovieClip =new MovieClip(); var loader:Loader =new Loader();

var url:URLRequest=new URLRequest(\"C:/Documents and Settings/Administrator/桌面/新建文件夹/sinian\"+i+\".jpg\"); loader.load(url);

loader.contentLoaderInfo.addEventListener(Event.COMPLETE ,loadf); function loadf(e) {

var temp:Loader=e.target.loader as Loader; temp.filters=[new BevelFilter(6,45,0xffffff,1,0,1,5,5,1,1,\"inner\添加的斜角滤镜

temp.scaleX=temp.scaleY=scale ;

mc.addChild(temp);

b?(temp.x=-temp.width /2,temp.y=-temp.height /2):0;

loader.contentLoaderInfo.removeEventListener(Event.COMPLETE ,loadf); }

return mc; }

//加载八张大图

for (var i:int=0; i<8; i++) {

var bigpic:MovieClip=loaderpic(1.2,i,true);

addChildAt(bigpic,0); bigpic.x=325; bigpic.y=300;

bigpic.name=\"bigpic\"+i; }

//加载八张小图

for (i=0; i<8; i++) {

var smallpic:MovieClip=loaderpic(0.4,i,true);

smallpic.mouseChildren=false;//大图不接受鼠标事件

addChildAt(smallpic,8);//因为大图已经占用七个图层，因此小图要从第八个图层添加 smallpic.buttonMode=true; smallpic.x=60*i; smallpic.y=20;

smallpic.scaleX=smallpic.scaleY=1-i*0.08; smallpic.n=i;

smallpic.name=\"smallpic\"+i; smallpic.startX=smallpic.x; arr.push(smallpic);

smallpic.addEventListener(MouseEvent.MOUSE_OVER,overf); smallpic.addEventListener(MouseEvent.MOUSE_OUT,outf); }

//鼠标滑过的函数 function overf(e) {

var temp:MovieClip=e.target as MovieClip; if (temp.n!=0) { new

Tween(temp,\"x\h,1,true);//缓动的对象是temp，缓动的方向是x方向，方式是线性的匀速没有其他方式,开始的位置,终点位置,持续的时间为0.5秒， }

temp.addEventListener(MouseEvent.CLICK ,clickf); }

//鼠标滑出的函数 function outf(e) {

var temp:MovieClip=e.target as MovieClip;

new Tween(temp,\"x\缓动的开始位置是当前的位置x坐标，终点变成原来的坐标x值了

temp.removeEventListener(MouseEvent.CLICK ,clickf); }

var talpha:Tween; var tscx:Tween; var tscy:Tween;

var trotation:Tween; function clickf(e) { for (i=0; i<8; i++) {

if (e.target.name==\"smallpic\"+i) {

var mc:MovieClip=getChildByName(\"bigpic\"+i) as MovieClip; setChildIndex(mc,7);

if (talpha!=null||tscx!=null||tscy!=null||trotation!=null) {

talpha.fforward(); tscx.fforward(); tscy.fforward(); trotation.fforward(); }

talpha=new Tween(mc,\"alpha\缓动的对象，对象的属性，alpha初始值为o，结束值为1，缓动次数为3 //或者用这三种之一

tscx=new Tween(mc,\"scaleX\

tscy=new Tween(mc,\"scaleY\这是缓动对mc缩放属性的设置 //或者

trotation=new Tween(mc,\"rotation\ } }}

实例八 加载网上的图片进行遮罩

//====创建新影片并设置其坐标及对载入的图片进行遮罩相当于容器sprite var mc:MovieClip =new MovieClip(); addChild(mc); mc.scaleX=3; mc.scaleY=3; mc.x=275; mc.y=200;

//==========加载网上图片 var url:URLRequest=new

URLRequest(\"http://hiphotos.baidu.com/azihennaini/pic/item/58a04022828da5649358079d.jpg\");

var loader:Loader =new Loader(); loader.load(url); addChild(loader); //========

loader.mask=mc;//加载的图片遮罩元件mc

loader.contentLoaderInfo.addEventListener(Event.COMPLETE ,f); var k:int=0;

function f(e:Event ) {stage.addEventListener(Event.ENTER_FRAME ,zhezhao); }

//=============遮罩即扇形旋转遮罩效果 var d:uint=0; var i:int=1;

stage.frameRate=24;

function zhezhao(e:Event ):void { var zhezhaomc:MovieClip =new Mc(); mc.addChild(zhezhaomc); zhezhaomc.rotation=d*3; d++;

if (d==120) {

while (mc.numChildren >0) { mc.removeChildAt(0);} d=0;

tumc.gotoAndStop(i+1); i++;

if (i==10) { i=0;}} }

实例九 旋转相册效果

var snd:Sound=new Yy();

var sp:Sprite=new Sprite(); addChild(sp);

sp.x=300,sp.y=300; var r:int=230;

var ma:Matrix=new Matrix();

ma.createGradientBox(480,480,0,-240,-240); sp.graphics.lineStyle(10);

sp.graphics.lineGradientStyle(\"radial\ma);

//线条渐变填充说明，渐变范围是240-250所以线条粗细是10，因此只取240-250的颜色 //sp.graphics .beginGradientFill(\"radial\0],ma)

sp.graphics.drawCircle(0,0,r);//外边的大圆 var arrYuan:Array=[]; var arrPic:Array=[];

var yuan0:MovieClip=new Yuan(); sp.addChild(yuan0);

yuan0.scaleX=yuan0.scaleY=1.8; for (var i:int=0; i<8; i++) { var yuan:Yuan=new Yuan(); sp.addChild(yuan); var pic:Pic=new Pic(); pic.gotoAndStop(i+1); sp.addChild(pic);

yuan.x=pic.x=r*Math.cos(i*Math.PI/4);//初始状态即为两者坐标相同 yuan.y=pic.y=r*Math.sin(i*Math.PI/4); arrYuan.push(yuan); arrPic.push(pic);

pic.addEventListener(MouseEvent.CLICK,ckF); }

var mc:MovieClip; function ckF(e) {

if (e.target.scaleX==1) {//如果点击的是小图则mc代表自己 mc=e.target; } else {

mc=new MovieClip();//如果点击的是大图则实例化一个空元件 }

snd.play(300); }

var n:Number=0;//控制角的度数增加

addEventListener(Event.ENTER_FRAME,frame); function frame(e) {

for (var i=0; iarrYuan[i].x=r*Math.cos(i*Math.PI/4+n);//让每个圆不停地运动

//这里只写了圆的位置转动而省去了写图片的位置转动，是因为下面 //有个圆和图片的距离m，初始状态就是二者的坐标相同所以m=0<因此会自动执行这两句 //arrPic[i].x=arrYuan[i].x;

// arrPic[i].y=arrYuan[i].y;

arrYuan[i].y=r*Math.sin(i*Math.PI/4+n); if (arrPic[i]==mc) {//如果这张图片是点击的小图

arrPic[i].x+=(yuan0.x-arrPic[i].x)/3;//缓动公式让小图向中间移动 arrPic[i].y+=(yuan0.y-arrPic[i].y)/3;

arrPic[i].scaleX=arrPic[i].scaleY+=(yuan0.scaleX-arrPic[i].scaleX)/3;//缩放也实现缓动

} else {//否则如果这张图片不是被点击的小图即大图

arrPic[i].x+=(arrYuan[i].x-arrPic[i].x)/2;//让大图回到小圆上去 arrPic[i].y+=(arrYuan[i].y-arrPic[i].y)/2;

arrPic[i].scaleX=arrPic[i].scaleY+=(arrYuan[i].scaleX-arrPic[i].scaleX)/2; } var

m=Math.sqrt((arrYuan[i].x-arrPic[i].x)*(arrYuan[i].x-arrPic[i].x)+(arrYuan[i].y-arrPic[i].y)*(arrYuan[i].y-arrPic[i].y));

if (m<5) {//只要两者之间的距离小于5，那么就让二者的坐标相等否则，系统会一直执行缓动并且越来越慢所以看起来感觉看到的是两个并重合 arrPic[i].x=arrYuan[i].x;// arrPic[i].y=arrYuan[i].y; } }

n+=0.015;//增加的是弧度值 }

实例10 图片撕裂的相册效果

var p:MovieClip =new Pic();//不用添加场景 var w:Number=p.width; var h:Number=p.height;

var num:uint=p.totalFrames; ////效果函数

function Effect():Sprite { var S:Sprite =new Sprite(); addChild(S);

var Spic:Sprite =new Sprite(); S.addChild(Spic);

var maskS:Sprite =new Sprite(); S.addChild(maskS);

maskS.graphics.beginFill(0xff0000);//遮罩矩形 maskS.graphics.drawRect(0,0,w/2,h); Spic.mask=maskS;

for (var i:uint =0; ipic.gotoAndStop(i+1);//注意元件帧数从1开始 pic.x=i*w;//横排图片 }

Spic.addEventListener(Event.ENTER_FRAME ,f); function f(e) {

for (var k:uint =0; kif (mc.x<=- w) {

mc.x=(Spic.numChildren -1)*w;//如果出了场景就接到最后一张后面 } } }

return S; } var sprL:Sprite=Effect();//制作思路是制作一个效果，然后得到两个，把另一个水平翻转即可

sprL.y=50

var sprR:Sprite=Effect(); sprR.y=50 sprR.x=w;

sprR.scaleX=-1;

实例11 2010河北中考数学连杆运动

//====画点和对应字母函数

function dianf(str:String,xx:Number ,yy:Number ):MovieClip { var mc:MovieClip =new MovieClip(); addChild(mc);

var m:Matrix=new Matrix ;

m.createGradientBox(20,20,-10,-10);

mc.graphics.beginGradientFill(GradientType.RADIAL ,[0xffffff*Math.random (),0xff0000],[1,1],[0,255],m); mc.graphics.drawCircle(0,0,5); mc.x=xx; mc.y=yy;

var txt:TextField =new TextField(); mc.addChild(txt);

var txtF:TextFormat =new TextFormat(); txtF.bold=true;

txtF.color=0xffff00; txtF.align=\"left\"; txtF.size=30;

txt.defaultTextFormat=txtF; txt.x=0; txt.y=10; txt.text=str; return mc; }

//=====实例化点和线段,圆

var mcA:MovieClip=dianf(\"A\var mcB:MovieClip=dianf(\"B\var mcK:MovieClip=dianf(\"K\var sp:Sprite =new Sprite(); addChild(sp);

sp.graphics.lineStyle(4,0x00ff00); sp.graphics.moveTo(mcA.x,mcA.y); sp.graphics.lineTo(mcB.x,mcB.y);

sp.graphics.drawCircle(mcK.x,mcK.y,100);

var mcM:MovieClip=dianf(\"M\//======给点M添加拖动事件

mcM.addEventListener(MouseEvent.MOUSE_DOWN ,dragf); function dragf(e) {

var Rect:Rectangle=new Rectangle(100,100,300,1);//===限制点M只能在线段AB上拖动 mcM.startDrag(true,Rect);

stage.addEventListener(Event.ENTER_FRAME ,f);//添加画三角形事件 }

stage.addEventListener(MouseEvent.MOUSE_UP ,upf); function upf(e) { mcM.stopDrag(); }

//====计算∠MKN的度数 MKtxt.x=100,MKtxt.y=10;

var sjx:Sprite =new Sprite();//=====注意实例化一个全局三角形容器是为了方便清空画线

addChild(sjx); function f(e) {

var MK:Number=Point.distance(new Point(mcM.x,mcM.y),new Point(mcK.x,mcK.y))/50;

MKtxt.text=\"MK长度\"+(MK);

var angM:Number=Math.atan2(mcK.y-mcM.y,mcM.x-mcK.x)*180/Math.PI;//点M的角度 var angMKN:Number =Math.acos ((4+MK*MK-9)/(4*MK))*180/Math.PI;//∠MKN的角度 var angN:Number=angM+angMKN; Ntxt.text=\"点的角度\"+angN;

var Nx:Number=mcK.x+100*Math.cos(- angN*Math.PI/180); var Ny:Number=mcK.y+100*Math.sin(- angN*Math.PI/180); sjx.graphics.clear();

sjx.graphics.lineStyle(3,0xff0000); sjx.graphics.moveTo(Nx,Ny);

sjx.graphics.lineTo(mcK.x ,mcK.y ); sjx.graphics.lineTo(mcM.x ,mcM.y); sjx.graphics.lineTo(Nx,Ny); }

实例12

场景中一个btn按钮

[SWF(frameRate=50)]

//===========先造一个矩形

var rect:MovieClip =new MovieClip(); addChild(rect);

rect.x=50;//矩形的左上角坐标 rect.y=50;

rect.graphics.lineStyle(3,0xff0000);

rect.graphics.drawRect(0,0,6*50,2*Math.sqrt (3)*50); rect.graphics.moveTo(6*50,2*Math.sqrt (3)*50); rect.graphics.lineTo(9*50,2*Math.sqrt (3)*50); //======字母函数

function zimu(xx:Number ,yy:Number,biaoqian:String ):TextField { var txt:TextField =new TextField();

var txtF:TextFormat =new TextFormat(); txtF.color=0xffffff; txtF.size=30; txtF.bold=true;

txt.x=50+xx;//因为矩形的左上角是50,50 txt.y=50+yy;

txt.defaultTextFormat=txtF;//注意要把文字设置放在前 txt.text=biaoqian; addChild(txt); txt.height =40 return txt;

}

//=========实例化字母

var A:TextField=zimu(0,2*Math.sqrt(3)*50,\"A\"); zimu(6*50,2*Math.sqrt (3)*50,\"B\"); zimu(6*50,0,\"C\"); zimu(0,0,\"D\");

zimu(9*50,2*Math.sqrt (3)*50,\"P\");

var O:TextField=zimu(3*50,2*Math.sqrt(3)*50,\"0\"); var F:TextField=zimu(9*50,2*Math.sqrt(3)*50,\"F\"); var E:TextField=zimu(3*50,2*Math.sqrt(3)*50,\"E\"); //=========== 点函数

function point():MovieClip { var mc:MovieClip =new MovieClip(); addChild(mc);

mc.graphics.beginFill(0xffffff); mc.graphics.drawCircle(0,0,5); return mc; }

//==========实例化点的做设置和坐标 var pointF:MovieClip=point(); var pointO:MovieClip=point(); pointF.x=50+9*50;

pointF.y=50+2*Math.sqrt(3)*50; pointO.x=O.x; pointO.y=O.y;

var pointE:MovieClip=point(); pointE.x=3*50+50;

pointE.y=50+2*Math.sqrt(3)*50; var pointG:MovieClip=point();

var len:Number=Point.distance(new Point(E.x,E.y),new Point(F.x,F.y)); pointG.x=E.x+len*Math.cos(-60*Math.PI/180); pointG.y=E.y+len*Math.sin(-60*Math.PI/180); var G:TextField=zimu(pointG.x,pointG.y,\"G\"); //=========

var n:int=0;//用来控制鼠标点击的奇偶次数而控制开始或运动 btn.addEventListener(MouseEvent.MOUSE_DOWN ,df); function df(e) { n%2==0?addEvener(Event.ENTER_var mcS:MovieClip entListener(FRAME,f);//添加帧=new Event.ENTER_频事件 MovieClip();//用

n++; FRAME,f):rem来装阴影的部分 } oveEventList

var vE:Number=1;

addChild(mcS);

mcS.filters =[new GlowFilter(),new BevelFilter()];

function f(e) {// 因为帧频是50，所以速度是6*50/6一共六秒即可 pointF.x-=1;

pointE.x<=A.x?vE*=-1:0; pointE.x-=vE;

//字母跟随点的坐标 F.x=pointF.x; F.y=pointF.y; E.x=pointE.x; E.y=pointE.y; //计算点G的坐标

len=Point.distance(new Point(E.x,E.y),new Point(F.x,F.y)); pointG.x=E.x+len*Math.cos(-60*Math.PI/180); pointG.y=E.y+len*Math.sin(-60*Math.PI/180); G.x=pointG.x;

G.y=pointG.y ;//画三角形 graphics.clear();

graphics.lineStyle(3,0xffffff*Math.random ()); //graphics.beginFill(0xff0000,0.5); graphics.moveTo(E.x,E.y); graphics.lineTo(F.x,F.y); graphics.lineTo(G.x,G.y); graphics.lineTo(E.x,E.y); mcS.graphics .clear()

if (pointF.x<9*50+50&&pointF.x>=8*50+50) { mcS.graphics.beginFill(0x0000ff);

mcS.graphics.moveTo(6*50+50,50+2*Math.sqrt(3)*50 ); mcS.graphics.lineTo(6*50+50,50);

mcS.graphics.lineTo(E.x+4*50*Math.cos(-60*Math.PI /180),E.y+4*50*Math.sin(-60*Math.PI /180)); mcS.graphics.lineTo(E.x ,E.y);

mcS.graphics.lineTo(6*50+50,50+2*Math.sqrt(3)*50); mcS.graphics.endFill(); }

if (pointF.x<8*50+50&&pointF.x>=50+6*50) { mcS.graphics.beginFill(0x00ff00);

mcS.graphics.moveTo(6*50+50,50+2*Math.sqrt(3)*50 );

mcS.graphics.lineTo(6*50+50,50+2*Math.sqrt(3)*50-(F.x-7*50)*Math.tan (60*Math.PI /180));

mcS.graphics.lineTo(F.x+4*50*Math.cos(-120*Math.PI /180),F.y+4*50*Math.sin(-120*Math.PI /180));

mcS.graphics.lineTo(E.x+4*50*Math.cos(-60*Math.PI /180),E.y+4*50*Math.sin(-60*Math.PI /180)); mcS.graphics.lineTo(E.x ,E.y);

mcS.graphics.lineTo(6*50+50,50+2*Math.sqrt(3)*50); mcS.graphics.endFill(); }

if (pointF.x<50+6*50&&pointF.x>=50+5*50) { mcS.graphics.beginFill(0xff0000); mcS.graphics.moveTo(F.x,F.y );

mcS.graphics.lineTo(F.x+4*50*Math.cos(-120*Math.PI /180),F.y+4*50*Math.sin(-120*Math.PI /180));

mcS.graphics.lineTo(E.x+4*50*Math.cos(-60*Math.PI

/180),E.y+4*50*Math.sin(-60*Math.PI /180)); mcS.graphics.lineTo(E.x ,E.y); mcS.graphics.lineTo(F.x,F.y); mcS.graphics.endFill(); }

if (pointF.x<50+6*50&&pointF.x>=50+5*50) { mcS.graphics.beginFill(0xff0000); mcS.graphics.moveTo(F.x,F.y );

mcS.graphics.lineTo(F.x+4*50*Math.cos(-120*Math.PI /180),F.y+4*50*Math.sin(-120*Math.PI /180));

mcS.graphics.lineTo(E.x+4*50*Math.cos(-60*Math.PI /180),E.y+4*50*Math.sin(-60*Math.PI /180)); mcS.graphics.lineTo(E.x ,E.y); mcS.graphics.lineTo(F.x,F.y); mcS.graphics.endFill(); }

if (pointF.x<50+5*50&&pointF.x>=50+3*50) { mcS.graphics.beginFill(0xffaacc); mcS.graphics.moveTo(F.x,F.y ); mcS.graphics.lineTo(G.x ,G.y);

mcS.graphics.lineTo(E.x ,E.y); mcS.graphics.lineTo(F.x,F.y); mcS.graphics.endFill(); }

if (pointF.x==O.x) {//当点F 走到点O的地方 F.x=pointF.x=9*50+50; vE*=-1;

removeEventListener(Event.ENTER_FRAME ,f); } }

实例13 绘制一次函数图像

场景中一个drawline_btn按钮一个clear_btn两个输入文本k_txt和b_txt

//定义函数比例系数、自变量、颜色变量; var k:Number,b:Number,n:Number=-10; var i:uint,color:uint;

//定义存储直线颜色的数组colorArr;

var colorArr:Array=[\"0xff0000\//定义容器，用于存储直线;

var spr:Sprite=this.addChild(new Sprite()) as Sprite;

drawline_btn.addEventListener(MouseEvent.CLICK,drawLine); function drawLine(e:MouseEvent):void {

//先移除，第一次结束后，再画的时候，先要移除事件，这样先前画了的线也就移除了; drawline_btn.removeEventListener(MouseEvent.CLICK,drawLine); k_txt.addEventListener(Event.CHANGE,input); b_txt.addEventListener(Event.CHANGE,input);

//把k_txt.text的文本强制转化基数意义的值，并赋值给k;b也同理; k=Number(k_txt.text); b=Number(b_txt.text);

//if里的运算符是比较运算符; if (k_txt.text==\"\"||k_txt.text==\"0\") {

this.removeEventListener(Event.ENTER_FRAME,drawline); } else {

color=colorArr[i%3]; i++;

spr.graphics.lineStyle(2,color);

spr.graphics.moveTo(n*20,-(k*n+b)*20);

this.addEventListener(Event.ENTER_FRAME,drawline); } }

//绘制一次函数的事件;

function drawline(e:Event):void { //经验值0.1; n+=0.1;

spr.graphics.lineTo(n*20,-(k*n+b)*20); if (n>=10) {

this.removeEventListener(Event.ENTER_FRAME,drawline); //n回到初始值; n=-10;

//绘线的起点回初始位置;

spr.graphics.moveTo(n*20,-(k*n+b)*20); //再次添加按钮事件;

drawline_btn.addEventListener(MouseEvent.CLICK,drawLine); } }

//定义自变量k和b的变化input函数; function input(e:Event):void { //要先添加按钮事件;

drawline_btn.addEventListener(MouseEvent.CLICK,drawLine); //称除绘制事件;

this.removeEventListener(Event.ENTER_FRAME,drawline); n=-10;

spr.graphics.lineStyle(2,color);

spr.graphics.moveTo(n*20,-(k*n+b)*20); }

//设置除画线按钮;

clear_btn.addEventListener(MouseEvent.CLICK,clearLine); function clearLine(e:MouseEvent):void {

//防止线没绘完，点了清除按钮，就移除事件，线也就没了 this.removeEventListener(Event.ENTER_FRAME,drawline); spr.graphics.clear();

k_txt.text=b_txt.text=\"\"; n=-10; i=0;

//再添加按钮事件;

drawline_btn.addEventListener(MouseEvent.CLICK,drawLine); }

实例14 纯脚本正余弦函数图像绘制

[SWF(stage.width=600,height=450,stage.frameRate=24)] var angle:Number=0;//

var dx:Number=1.75;//x方向的增加值 var dn:Number=6;//角度的增量 var xx:Number=0;//点的横坐标 var yy:Number=0;

var color:uint;//曲线的颜色 var i:uint;//纪录鼠标按下的次数

var colorarr:Array=[\"0xff0000\var btnarr:Array=[];//按钮数组 var w:Number=stage.stageWidth; var h:Number=stage.stageHeight; //在容器中创建坐标系

var sp:Sprite=new Sprite(); addChild(sp); sp.x=40; sp.y=h/2;

with (sp) {//相当于省略每句的sp graphics.lineStyle(2,0);

graphics.moveTo(-20,0); graphics.lineTo(w-60,0); graphics.beginFill(0x000000);

//x轴的箭头，用画三角形的方法，

graphics.drawTriangles(Vector.([w-60,0,w-70,-3,w-70,3])); //数值型数组参数为三角形的三个点的横纵坐标 //下面是纵轴和其箭头

graphics.moveTo(0,-h/2+30); graphics.lineTo(0,h/2-30);

graphics.drawTriangles(Vector.([0,-h/2+30,-3,-h/2+40,3,-h/2+40])); graphics.endFill(); //下面是坐标正负1

graphics.moveTo(0,-50); graphics.lineTo(5,-50); graphics.moveTo(0,50); graphics.lineTo(5,50); }

//下面是xy轴添加xy符号 var str:String=\"xy\";

for (var n:uint =0; n<2; n++) {

var txt1:TextField =sp.addChild (new TextField()) as TextField; txt1.defaultTextFormat=new TextFormat(\"Times New Roman\

txt1.autoSize=TextFieldAutoSize.CENTER;

txt1.text=str.charAt(n);//获取字符串中的指定第n个字符 txt1.x=(1-n)*(w-75)+5; txt1.y=n*(-h/2+20); txt1.selectable=false; }

var numArr:Array=[\"O\ for (n=0; n<3; n++) {

var txt2:TextField =sp.addChild (new TextField())as TextField;

txt2.defaultTextFormat=new TextFormat(\"Times New Roman\ txt2.autoSize=TextFieldAutoSize.CENTER; txt2.text=numArr[n]; txt2.x=-20;

txt2.y=n*(-50-txt2.height /2); //文本的注册点在左上角

n==2?(txt2.x=-25,txt2.y=50-txt2.height /2):0; txt2.selectable=false; }

//下面是绘制正弦和余弦曲线的容器

var line1:Sprite=sp.addChild (new Sprite())as Sprite; var line2:Sprite=sp.addChild (new Sprite())as Sprite; //两个按钮的设置

var word:Array=[\"正弦曲线\余弦曲线\"]; for (var j:uint =0; j<2; j++) {

var btn:Sprite =addChild(new Sprite())as Sprite; btn.x=w-200+70*j; btn.y=h-80;

btn.graphics.beginFill(0x0000ff);

btn.graphics.drawEllipse(-30,-13,60,26);

btn.graphics.endFill(); btn.buttonMode=true;

var btntxt:TextField =btn.addChild (new TextField())as TextField; btntxt.defaultTextFormat=new TextFormat(\"华文行楷\btntxt.autoSize=TextFieldAutoSize.CENTER; btntxt.text=word[1];

btntxt.x=- btntxt.width/2; btntxt.y=- btntxt.height/2; btntxt.selectable=false; btnarr.push(btn); }

//正弦曲线按钮执行的事件

btnarr[0].addEventListener(MouseEvent.CLICK ,drawline1); function drawline1(e) { line1.graphics.clear(); line2.graphics.clear();

line1.graphics.lineStyle(3,colorarr[i%3]);

btnarr[0].removeEventListener(MouseEvent.CLICK ,drawline1);

btnarr[1].removeEventListener(MouseEvent.CLICK ,drawline2) //画线的时候删除两个按钮的侦听事件即让量按钮不再其作用 addEventListener(Event.ENTER_FRAME ,drawsine); i++; }

//画正弦曲线函数

function drawsine(e) { xx+=dx;

yy=-50*Math.sin(angle*Math.PI/180); angle+=dn;

line1.graphics.lineTo(xx,yy);

if (xx>=w-74) {//画线结束后删除画线函数，重新添加两个按钮侦听事件 removeEventListener(Event.ENTER_FRAME ,drawsine); btnarr[0].addEventListener(MouseEvent.CLICK ,drawline1); btnarr[1].addEventListener(MouseEvent.CLICK ,drawline2); xx=0; yy=0; } }

//余弦函数按钮添加事件

btnarr[1].addEventListener(MouseEvent.CLICK ,drawline2); function drawline2(e) { line1.graphics.clear(); line2.graphics.clear();

line2.graphics.lineStyle(3,colorarr[i%3]);

btnarr[0].removeEventListener(MouseEvent.CLICK ,drawline1); btnarr[1].removeEventListener(MouseEvent.CLICK ,drawline2) addEventListener(Event.ENTER_FRAME ,drawcose); line2.graphics.moveTo(0,-50)

//画线的时候删除两个按钮的侦听事件即让量按钮不再其作用 i++; }

//画余弦函数图像

function drawcose(e) { xx+=dx;

yy=-50*Math.cos(angle*Math.PI/180); angle+=dn;

line2.graphics.lineTo(xx,yy);

if (xx>=w-74) {//画线结束后删除画线函数，并添加两个按钮的事件侦听 removeEventListener(Event.ENTER_FRAME ,drawcose); btnarr[0].addEventListener(MouseEvent.CLICK ,drawline1);

btnarr[1].addEventListener(MouseEvent.CLICK ,drawline2);xx=0; yy=-50 angle=0; } }

实例15 动态坐标系的绘制

var zuobiaoxi:Sprite =new Sprite(); addChild(zuobiaoxi); zuobiaoxi.x=275; zuobiaoxi.y=200;

function kedu(X:Number ,Y:Number ,shuzhi:String ):TextField { var txt:TextField =new TextField();

var textformat:TextFormat =new TextFormat() textformat.color =0x00ffaa textformat.font =\"隶书\" textformat.bold=true textformat.size =15

txt.defaultTextFormat =textformat txt.text=shuzhi; txt.x=X; txt.y=Y; return txt; }

function juxing(XX:Number ,YY:Number ,W:Number ,H:Number ):Shape { var juxingtiao:Shape =new Shape();

juxingtiao.graphics.lineStyle(2,0x0000ff); juxingtiao.graphics.beginFill(0x000000); juxingtiao.graphics .drawRect(0,0,W,H) juxingtiao.graphics.endFill(); juxingtiao.x=XX; juxingtiao.y=YY;

return juxingtiao; }

zuobiaoxi.graphics.lineStyle(2,0x0000ff); var i:Number=-275;

addEventListener(Event.ENTER_FRAME ,zuobiaozhou);

function zuobiaozhou(e) {

if (i<=270) {//从左向右画线//=========x轴的画线 zuobiaoxi.graphics.moveTo(-275,0); zuobiaoxi.graphics.lineTo(i,0); i+=5;

i%50==0?zuobiaoxi.addChild(kedu(i,0,\"\"+i)):0;

i%50==0?zuobiaoxi.addChild(juxing(i-3,0-10,6,10)):0;

//0减去10是为了在x轴上即向上偏移10个像素i减去三是因为矩形条宽为6所以向左偏移3个像素就可以中心对对齐 }

if (i==270) {//275为边界稍微偏左点设置为270 zuobiaoxi.graphics.moveTo(270,0);//==x画出箭头 zuobiaoxi.graphics.lineTo(260,-10); zuobiaoxi.graphics.lineTo(270,0);

zuobiaoxi.graphics.lineTo(260,10); }

if (i>270&&i<=670) {//=====y轴的画法方向从下往上因为高是400所以i的取值范围是400

zuobiaoxi.graphics.moveTo(0,200);

zuobiaoxi.graphics.lineTo(0,200-(i-270)); i+=5;

i%50==0?zuobiaoxi.addChild (kedu(0,200-(i-270)+30,\"\"+(i-270-200-30))):0;//减去三十为了y轴的0的位置和x轴0 //的位置重合

i%50==0&&i-270-200-30!=0?zuobiaoxi.addChild(juxing(0,200-(i-270)+30,10,6)):0;

//并且不等于0 是因为y轴上等于0时不用再添加矩形条 }

if (i==670) {//y轴的箭头设置

zuobiaoxi.graphics.moveTo(0,-200); zuobiaoxi.graphics.lineTo(-10,-190); zuobiaoxi.graphics.lineTo(0,-200); zuobiaoxi.graphics.lineTo(+10,-190); }}

实例16 分组加分课件

场景中，一个zushutxt表示分几个组，一个zutxt表示第几组一个fentxt表示给该小组加的分数共三个输入文本 var zushu:int;

var sp:Sprite =new Sprite (); addChild(sp);

var zuarr:Array=[]; ///画矩形条

function rect(color):MovieClip { var rectmc:MovieClip =new MovieClip();

sp.addChild(rectmc);

rectmc.filters =[new BevelFilter()];

rectmc.graphics.lineStyle(2,color); rectmc.graphics.beginFill(color);

rectmc.graphics.drawRect(-25,0,-50,-20); rectmc.graphics.endFill(); return rectmc; }

function txt(color:uint,str:String ):TextField { var txtt:TextField =new TextField(); addChild(txtt);

txtt.filters =[new BevelFilter()];

var txtF:TextFormat =new TextFormat(); txtF.size=20; txtF.bold=true; txtF.color=color;

txtt.defaultTextFormat=txtF; txtt.text=str;

txtt.autoSize=\"center\"; return txtt; }

zushutxt.addEventListener(Event.CHANGE ,cf); function cf(e) {

while (sp.numChildren >0) {/// sp.removeChildAt(0); } init();

zushu=int(zushutxt.text);

for (var i=0; ivar co:uint=0xffffff*Math.random()+0.2; var mc:MovieClip=rect(co); zuarr.push(mc);//矩形条数组 mc.x=150+i*(20+50); mc.y=400-5;

var zuname:String =\"第\"+(i+1)+\"组\"; var txt:TextField=txt(co,zuname); sp.addChild(txt); txt.x=mc.x-80; txt.y=mc.y+20; } }

var zu:Number; var fen:Number;

var fenarr:Array=[];

zutxt.addEventListener(Event.CHANGE ,f1); fentxt.addEventListener(Event.CHANGE ,f1); function f1(e) { fen=Number(fentxt.text); zu=int(zutxt.text);

for (var j:int =0; jzuarr[j].height+=fen*2,fenarr[j]+=fen; } } }

//画分数竖线

function init() {

var shuxian:Shape=new Shape(); shuxian.filters =[new BevelFilter()] sp.addChild(shuxian);

shuxian.graphics.lineStyle(4,0xff0000); shuxian.graphics.moveTo(500,400); shuxian.graphics.lineTo(50,400);

shuxian.graphics.lineTo(50,50); var jian:MovieClip =new jiantou(); sp.addChild(jian); jian.x=50; jian.y=50;

jian.rotation=-90;

for (var k:int=50; k<360; k+=10) { var len:Number;

shuxian.graphics.lineStyle(1,0xff0000); shuxian.graphics.moveTo(50,50+k);

shuxian.graphics.lineTo(50+10,50+k); var fen:TextField =new TextField();

var txtF:TextFormat =new TextFormat(); txtF.size=15; txtF.color=0xffffff;

fen.defaultTextFormat=txtF; fen.text =String((k-50)/10*5);

(k-50)/10*5%10==0?addChild(fen):0; fen.x=50-30; fen.y=500-(60+k) ; } }

实例17 弧长相等验证课件 场景中一个输入文本num_txt

var R:Number=200;//大半圆半径

//======用来绘制大半圆和每个小半圆的容器 var sp:Sprite =new Sprite(); addChild(sp); sp.x=275; sp.y=300;

var bigcircle:MovieClip =new MovieClip(); sp.addChildAt( bigcircle,0); bigcircle.graphics.moveTo(R,0);

bigcircle.graphics.lineStyle(3,0xffffff);

for (var i:int =180; i<360; i++) {//画大半圆周//因为是从左端点开始所以角度从180开始

bigcircle.graphics.lineTo(R*Math.cos (i*Math.PI /180),R*Math.sin (i*Math.PI /180)); }

//=========从库中实例化两个球

var ball:MovieClip =new Ball();//实例化大球 sp.addChildAt(ball,1);

ball.x=- R;//把大球放在大半圆的左端点

var ballsmall:MovieClip =new Ball();//实例化小球 sp.addChildAt(ballsmall,2); ballsmall.x=- R;

ballsmall.scaleX=ballsmall.scaleY=0.5;

//=======随机产生若干整数，如果他们的和等于200则得到若干个半径 var num:int=int(num_txt.text);//小圆的个数 var arr:Array=[];//用来存放若干个小球的半径

var rNum:int=0;//用来累计计算前n-1个小球的半径和

smallPoint();//=============调用计算每个小圆半径函数 function smallPoint() {

for (var j:int =0; jif (j//用R=200除以小圆的个数得到每个小圆的平均半径，然后在这个平均半径中随机得到一个整数作为该小圆的半径

rNum=rNum+r;//累计计算这若干个半径的和 //trace(r);

arr.push(r);//把得到的每个小圆半径添加到数组中 } else {//====最后一个小圆半径得到方法

//用总半径R=200减去前面的随机得到的若干个半径得到最后的一个半径这样就保证了这n个小球的半径和等于大圆的半径R var rr:int=R-rNum;

arr.push(rr);//把最后一个半径添加到数组中 //trace(rr); } } }

//======画上面的若干个小圆

var circlePointarr:Array=[];//用来存放若干个小圆的圆心坐标 var b:int=0;//可控制半径的和来控制各个小半圆的圆心坐标 var circle:MovieClip;

drawsmallcircle();//调用画小圆函数 function drawsmallcircle() { for (var j=0; jj==0?b=arr[j]:b=b+arr[j-1]+arr[j];

//第一个圆的圆心坐标即是左边端点加上第一个半径

//后面则是是把前面的半径和加起来再加上前面的一个半径和现在的一个圆的半径 circle =new MovieClip(); sp.addChildAt(circle,j+3);

circle.graphics.lineStyle(2,0xffffff);

circle.graphics.moveTo(-arr[j],0);

for (var m:int =180; m<360; m++) {//绘制若干个小半圆

circle.graphics.lineTo(arr[j]*Math.cos (m*Math.PI /180),arr[j]*Math.sin (m*Math.PI /180)); }

circle.x=- R+b;//每个小半圆的x坐标注意是从大圆的左端点开始所以用-R加上b circlePointarr.push(circle.x); } }

//========场景添加鼠标单击事件：两个小球开始旋转 stage.addEventListener(MouseEvent.CLICK ,f); function f(e) {

addEventListener(Event.ENTER_FRAME ,ff); }

var ang:int=180;//同样是因为从左端开始旋转所以角度设置初始值为180 var Ang:int;//用来计算每个小圆的旋转角度

var len:Number=0;//用来累从第一个小圆到n-1个小圆的弧长 var l:Number;//用来计算小球在每个小圆上分别走过的弧长

var n=0;//控制每个小球运动的时候每个小圆的圆心坐标数组索引值 function ff(e) { if (ang<=360) {

ball.x=R*Math.cos(ang*Math.PI/180); ball.y=R*Math.sin(ang*Math.PI/180); //计算此时大圆的总弧长

var L:Number=(ang-180)*Math.PI*R/180;

//因为角度是从左端点即180度开始的而实际上大球旋转过的圆心角应 该减去原有的180度

Ang=(L-len)*180/(Math.PI *arr[n]);//用大球走过的弧长减去累计弧长 //计算这个弧长对于第一个小圆应该旋转地角度

l=Ang*Math.PI*arr[n]/180;//计算此时小球在该小圆上走过的弧长 trace(Ang);

Ang>=180?[len=len+l,n++,Ang=0]:0;//当每个小球转过180度后,就计算小球走过的累计弧长

//并且让此时每个小球的旋转角度归零

ballsmall.x=circlePointarr[n]+arr[n]*Math.cos((180+Ang)*Math.PI/180); //同样因为小圆也是从左端点开始旋转所以应该是用180加上上面的旋转角度 ballsmall.y=arr[n]*Math.sin((180+Ang)*Math.PI/180); ang++; } }

//文本框改变参数重新开始

num_txt.addEventListener(Event.CHANGE ,chang);

function chang(e) {

removeEventListener(Event.ENTER_FRAME ,ff);//先移除大小球旋转帧频事件 while (sp.numChildren >3) {//清空若干个小半圆 sp.removeChildAt(3); }

circle.graphics.clear();

arr=[];//再把一些数据还原归零 circlePointarr=[]; b=0; n=0; rNum=0; ang=180; len=0;

ballsmall.x=- R; ball.x=- R;

ball.y=ballsmall.y=0; num=int(num_txt.text);

smallPoint();//重新掉用计算小圆半径函数; drawsmallcircle();//重新绘制小圆

addEventListener(Event.ENTER_FRAME ,ff);//再次添加点击事件 }

实例18 模拟硬币随机投掷效果

function cir(color:uint ):MovieClip { var circ:MovieClip = new MovieClip(); circ.graphics.beginFill(color);

circ.graphics.drawCircle(400,200,50); circ.graphics.endFill(); addChild(circ); return circ; }

cir(0xffffff);

function rect(color:uint ,xx:Number ,yy:Number,h:Number ):MovieClip { var juxing:MovieClip =new MovieClip(); juxing.graphics.beginFill(color);

juxing.graphics.drawRect(xx,yy,20,h); juxing.graphics.endFill(); addChild(juxing); return juxing; }

txt.text=\"硬币\";

var txtsp:Sprite =new Sprite(); addChild(txtsp);

var fanmian:Number=0; var zhengmian:Number=0; var total:Number=0;

btn.addEventListener(MouseEvent.CLICK ,clickf);

function clickf(e) { total++;

rect(0xffffff,100,(300-total),total); rect(0xffffff,200,(300-total),total); txt.text=\"\";

var num:Number=Math.floor(Math.random()*2); if (num==0) { zhengmian++; txt.text=\"正面\";

txtsp.addChild(cir(0xeeaacc)); } else {

txt.text=\"反面\";

txtsp.addChild(cir(0x0000ff)); fanmian++; }

jjuxingtiao.text=\"矩形条总高度代表总次数，红色和蓝色分别代表正面和 反面的次数\"

rect(0xeeaacc,100,(300-zhengmian),zhengmian); rect(0x0000ff,200,(300-fanmian),fanmian); addChild(txt);

jilutxt.text=\"反面\"+\":\"+fanmian+\"正面\"+\":\"+zhengmian+\"点击总数\"+\"=\"+total; }

实例19 可以改变单位长度的的一次函数图像绘制

//场景中有个shuzhitxt和fuhaotxt文本框，可以拖动单位点改变刻度， var W:Number=stage.stageWidth; var H:Number=stage.stageHeight; var zhou:Sprite =new Sprite();

var yuandian:MovieClip =new Dian(); addChild(yuandian);

yuandian.buttonMode=true; //====原点

//yuandian.scaleX=yuandian.scaleY=2; yuandian.x=stage.stageWidth/2; yuandian.y=stage.stageHeight/2; //====单位点

var danweidian:MovieClip =new Dian(); addChild(danweidian); danweidian.y=H/2; danweidian.x=W/2+50;

danweidian.buttonMode=true;

//danweidian.scaleX=danweidian.scaleY=2; //=====轴线

graphics.lineStyle(2,0xffff00); graphics.moveTo(0, H/2);

graphics.lineTo(W, H/2);

graphics.lineStyle(2,0xffff00); graphics.moveTo(W/2, H); graphics.lineTo(W/2, 0); var jt:MovieClip=new Jt(); //========箭头 addChild(jt);

jt.scaleX=jt.scaleY=0.5; jt.x=W-5;// jt.y=H/2;

var jt0:MovieClip =new Jt(); addChild(jt0);

jt0.scaleX=jt0.scaleY=0.5; jt0.rotation=-90; jt0.x=W/2; jt0.y=8;

//=====用来装每个小线段和数字的容器 var sp:Sprite =new Sprite(); addChild(sp);

//===给单位点添加鼠标按下事件

danweidian.addEventListener(MouseEvent.MOUSE_DOWN ,df); function df(e) {

for (var k:int =sp.numChildren -1; k>=0; k--) {//鼠标按下后清空容器 sp.removeChildAt(k); }

var rect:Rectangle=new Rectangle(W/2,H/2,W,1); danweidian.startDrag(false,rect);//单位点开始拖动 }

//====给单位点添加抬起事件

stage.addEventListener(MouseEvent.MOUSE_UP ,upf); function upf(e) {

danweidian.stopDrag();//停止拖动 intf();//调用函数 }

//==========先调用一次 intf();

//每个数字函数

function txtf(shuzi:Number,xx:Number ,yy:Number ) { var txt:TextField =new TextField(); txt.width=20; sp.addChild(txt);

var txtF:TextFormat =new TextFormat(); txtF.bold=true; txtF.color=0xffffff; txtF.size=15; txtF.align=\"left\";

txt.defaultTextFormat=txtF; txt.text=String(shuzi);

txt.x=xx; txt.y=yy; }

//盛放函数图像的容器 var numk:Number; var numb:Number; var n:int; var n0:int;

var danweichangdu:Number; //=======数字和小线段函数 function intf() {

danweichangdu=danweidian.x-W/2; n=int(W/danweichangdu)/2; n0=int(H/danweichangdu)/2;

//循环添加y轴上的小线段和数字

for (var k:Number =H/2-n0*danweichangdu; kvar mc0:MovieClip =new MovieClip(); sp.addChild(mc0);

//注意这里是从负的到正的增加，步长为一个单位长度 mc0.graphics.clear();

mc0.graphics.lineStyle(1,0xffffff);//y轴上的每段小线段 mc0.graphics.moveTo(W/2,k);

mc0.graphics.lineTo(W/2-12,k);

k!=H/2?txtf((H/2-k)/danweichangdu,W/2+5,k-10):0;//因为x轴上已经有0，因此y轴上不能再要0 }

//循环添加x轴上的小线段和数字

for (var j:Number =W/2-n*danweichangdu; jvar mc:MovieClip =new MovieClip(); sp.addChild(mc);

//注意这里是从负的到正的增加，步长为一个单位长度 mc.graphics.clear();

mc.graphics.lineStyle(1,0xffffff);//x轴上的每段小小线段 mc.graphics.moveTo(j,H/2);

mc.graphics.lineTo(j,H/2-10);

txtf((j-W/2)/danweichangdu,j-10,H/2+10);//为了把数字放在相应刻度下面所以让y坐标+10

//让横坐标向左移动10个像素这是经验值可以改变 }

var mctuxiang:MovieClip =new MovieClip();//函数图像元件 sp.addChild(mctuxiang);

btn.addEventListener(MouseEvent.CLICK,clf); var m:Number=- n;//控制函数自变量 function clf(e) {

numk=Number(txt1.text); numb=Number(txt2.text);

mctuxiang.graphics.lineStyle(1,0xffffff);

mctuxiang.graphics.moveTo(W/2-n*danweichangdu,H/2-(-n*numk+numb)*danweichangdu);//注意起始点是自变量为场景的最左端开始的 stage.addEventListener(Event.ENTER_FRAME ,entf); }

function entf(e) {

//当画线事件开始后删除点击事件

if (numk<0) {//当一次项系数小于0时候因为是递减函数所以限制最大值

if (H/2-(m*numk+numb)*danweichangdubtn.removeEventListener(MouseEvent.CLICK,clf);

mctuxiang.graphics.lineTo(W/2+m*danweichangdu,H/2-(m*numk+numb)*danweichangdu); m+=0.5;

} else {//当函数值超出场景是停止画线

stage.removeEventListener(Event.ENTER_FRAME ,entf); } }

if (numk>0) {//当一次项系数大于0时候，是递增函数所以限制最小值

if (H/2-(m*numk+numb)*danweichangdu>0-50) {//函数值最小值为0-50，-50是为了场景最上边再减少50个像素，也属于经验值可以随意这样更逼真图像 btn.removeEventListener(MouseEvent.CLICK,clf);

mctuxiang.graphics.lineTo(W/2+m*danweichangdu,H/2-(m*numk+numb)*danweichangdu); m+=0.5;

} else {//当函数值超出场景是停止画线

stage.removeEventListener(Event.ENTER_FRAME ,entf); }} }

btn0.addEventListener(MouseEvent.CLICK ,clearf);//清除按钮添加清除事件 function clearf(e) {

mctuxiang.graphics.clear(); }

txt1.addEventListener(Event.CHANGE ,inputf);//两输入文本添加输入事件 txt2.addEventListener(Event.CHANGE ,inputf); function inputf(e) {

m=- n;//重新赋值开始画线的自变量值为了是画线起点重新赋值

btn.addEventListener(MouseEvent.CLICK,clf);//再添加按钮画线事件}}

实例20 七巧板课件

var sound:Sound =new Sound();

var channel:SoundChannel=new SoundChannel(); var

url:String=\"http://courseware.eduwest.com/courseware/0830/content/shiting/yu

eqi/1.mp3\";

var req:URLRequest=new URLRequest(url); sound.load(req);

channel=sound.play();

var arr:Array=[mc1,mc2,mc3,mc4,mc5,mc6,mc7];//七巧板的七小块

var arrx:Array=[mc1.x,mc2.x,mc3.x,mc4.x,mc5.x,mc6.x,mc7.x];//用来记录当前的小图片的原始位置用来复原

var arry:Array=[mc1.y,mc2.y,mc3.y,mc4.y,mc5.y,mc6.y,mc7.y]; var sp:Sprite =new Sprite(); addChild(sp);

for (var i:int=0; iarr[i].addEventListener(MouseEvent.MOUSE_DOWN ,df1);// arr[i].addEventListener(MouseEvent.MOUSE_UP ,upf);

arr[i].doubleClickEnabled=true;//注意使用双击事件之前要允许使用双击 arr[i].addEventListener(MouseEvent.DOUBLE_CLICK ,xuanzhuanf); }

//========鼠标按下拖动事件 function df1(e) { var mc=e.target;

sp.setChildIndex(mc,sp.numChildren -1);//点击的时候把当前图片设置为最高层 mc.startDrag(); } } var v:Number; //=========鼠标抬起停止拖动 //angtxt.restrict=\"-function upf(e) { 0123456789\";//显示输//var mc=e.target; 入的只能是数字 //mc.stopDrag();// angtxt.restrict=\"-0-stopDrag();//只要停止拖动即可 9\"; //=========旋转函数

function xuanzhuanf(e) { v=Number(angtxt.text); var mc=e.target;

mc.addEventListener(Event.ENTER_FRAME ,f);//每个图片添加帧频事件 function f(e) {

mc.rotation+=v;//进入帧频后开始旋转 }

mc.addEventListener(MouseEvent.CLICK ,stopf);//添加单击删除帧频旋转事件 function stopf(e) {

mc.removeEventListener(Event.ENTER_FRAME ,f);} chonglaibtn.addEventListener(MouseEvent.CLICK ,chongzuof);//重来按钮添加的恢复原形事件

function chongzuof(e) {

v=0;//点击重来按钮后转动速度变为0则停止下来了 for (i=0; iarr[i].rotation=0;//每个图片的旋转角度都恢复为0

arr[i].removeEventListener(Event.ENTER_FRAME ,f);

//每个图片都删除帧频事件否则再点击时候原来旋转地还会继续旋转地}}}

实例21 求一个数的公约数

txt.restrict=\"0123456789\";//输入文本txt var num:int=int(txt.text);//输入文本的值 var txtt:TextField =new TextField(); addChild(txtt); function intf() { txtt.multiline=true; txtt.wordWrap=true;

var txtF:TextFormat=new TextFormat(); txtF.color=0xffffff; txtF.size=30; txtF.bold=true;

txtt.autoSize=\"center\";//注意要使文本高度自动根据文字多少调整，必须加上这句代码 txtt.defaultTextFormat=txtF; txtt.text=\"\"; txtt.numLines;

txtt.background=true;

txtt.backgroundColor=0x0000ff; txtt.border=true;//文本框有边框

txtt.borderColor=0xffaacc;//文本框边框为蓝色 txtt.x=125; txtt.y=180; txtt.width=300;

for (var i:int=0; i<=num; i++) {

//如果一个整数除以另一个整数减去取整的结果为0说明就是被这个数整除

if (num/i-int(num/i)==0&&i} else if (num/i-int(num/i)==0&&i==num) {//最后一个因数显示后用句号 txtt.appendText(String(i)+\"。\"); }

//转化成字符串后添加到数组中} }

txt.addEventListener(Event.CHANGE,f); function f(e) { num=int(txt.text); txtt.text=\"\"; intf(); }

intf();

实例22 认识三角形

var con:Sprite =new Sprite(); var dz:Sprite =new Sprite(); var sjx:Sprite; addChild(con); var cl:MovieClip; var p1,p2,p3:Point; var n:uint=0; var str:String;

stage.addEventListener(MouseEvent.CLICK ,dianf); function dianf(e) { n++;

switch (n) { case 1 :

p1=new Point(mouseX,mouseY); str=\"A\";

var ma=drawT(p1,str); break; case 2 :

p2=new Point(mouseX,mouseY); str=\"B\";

drawT(p2,str); break; case 3 :

p3=new Point(mouseX,mouseY); str=\"C\";

drawT(p3,str);

drawF(p1,p2,p3);//调用画三角形函数

sjx_txt.text=PDsjx(p1,p2,p3);//调用文本框三角形分类 break; } }

//画点和字母函数

function drawT(p:Point,str:String) { cl=new MovieClip(); con.addChild(cl);

cl.graphics.beginFill(0x0000ff);

cl.graphics.drawCircle(p.x,p.y,3);//小圆点 var txt:TextField =new TextField();//字母 con.addChild(txt); txt.width=28; txt.height=28;

p.x>275?txt.x=p.x+13:txt.x=p.x-26;//让字母始终在点的外边防止三角形掩盖了三个字母

p.y>250?txt.y=p.y+13:txt.y=p.y-26; txt.text=str;

var fmt:TextFormat=new TextFormat(); fmt.size=26;

fmt.color=0xff0000; fmt.bold=true;

txt.setTextFormat(fmt); }

//============画三角形函数

function drawF(pa:Point ,pb:Point ,pc:Point ) { sjx =new Sprite(); addChild(sjx);

sjx.graphics.lineStyle(2,0xff0000); sjx.graphics.beginFill(0x00ff00);

sjx.graphics.moveTo(pa.x,pa.y);

var sjx.graphics.lineTo(pb.x,pb.y);

b:Number=int(sjx.graphics.lineTo(pc.x,pc.y);

Point.distance(sjx.graphics.lineTo(pa.x,pa.y);

pc,pa)); //sjx.graphics .drawTriangles()

var }

c:Number=int(//============判断三角形函数

Point.distance(

function PDsjx(pa,pb,pc):String {

pa,pb));

var str:String; var s:Number var a:Number=int(Point.distance(pb,pc));//三条=(a+b+c)/2; 边的距离

var angA:Number =int(2*Math.asin (Math.sqrt

((s-b)*(s-c)/(b*c)))*180/Math.PI*10)/10;//利用半角公式求角度并且除以10在乘以10保留一位小数

var angB:Number =int(2*Math.asin (Math.sqrt ((s-a)*(s-c)/(a*c)))*180/Math.PI*10)/10; var angC:Number=180-angA-angB;

if (angA>89.5&&angA<90.5||angB>89.5&&angB<90.5||angC>89.5&&angC<90.5) {//这里只要在范围内都近似认为直角三角形 str=\"直角三角形\";

} else if (angA<90&&angB<90&&angC<90) { str=\"锐角三角形\"; } else {

str=\"钝角三角形\"; }

return str; }

//============清楚按钮

cls_btn.addEventListener(MouseEvent.CLICK, clsf); function clsf(e) {

e.stopPropagation();//限制点击按钮时候不属于点击场景 n=0;////初始化一些数据

con.graphics.clear();//清除图形 sjx.graphics.clear(); while (con.numChildren !=0) { con.removeChildAt(0); sjx_txt.text=\"\"; }

}

实例23 任意正多边形的滚动演示

setChildIndex(txt,0)//把输入文本和签名设置层深 setChildIndex(qianming,1)

intf()//为了防止黑屏先调用一次函数 txt.addEventListener(Event.CHANGE ,f) function f(e){//文本每次改变调用一次函数 intf()}

function intf(){

for(var k=numChildren-1;k>1;k--){

//每次调用函数前要先把场景中的正方形删除 removeChildAt(k)}

var n:int=int(txt.text);//初始正多边形的边数 //画多边形的影片

var spline:Sprite;//画横线的容器

var r:Number=50;//初始多边形的外接圆半径

var len:Number=2*r*Math.sin(Math.PI/n);//初始正多边形的边长 function zhengduobianxing(n ,r):MovieClip { //===========画正多边形 //参数为边数外接圆半径

len=2*r*Math.sin(Math.PI/n);//正多边形的边长随着边数和半径的参数 改变而改变

var mc:MovieClip =new MovieClip(); addChild(mc);

mc.graphics.lineStyle(1,0xffffff*Math.random ()); var matrix:Matrix =new Matrix();

matrix.createGradientBox(10,10,0,-5,0);

mc.graphics.beginGradientFill(GradientType.LINEAR ,[0xffffff*Math.random (),0xffffff*Math.random ()],[1,1],[0,255],matrix,\"reflect\"); mc.graphics.moveTo(r,0);

for (var i:int =0; imc.graphics.lineTo(r*Math.cos (ang),r*Math.sin (ang)); }

mc.x=0;

;//正多边形的初始坐标 mc.y=100

mc.rotation =(180-360/n)/2;//因为是从（r，0）开始画线的， //为了让每个正多边形的最下边的水平放置 //所以要先把每个多边形旋转一个内角的一半 //==============画横线 spline =new Sprite(); addChild(spline);

spline.y=mc.y+r*Math.cos(Math.PI/n);

//横线的纵坐标是正多边形的坐标加上边心距才能保证始终与最下边的边重合 spline.graphics.lineStyle(3,0xffffff,0.6); spline.graphics.moveTo(0,0); spline.graphics.lineTo(550,0); return mc; }

var mcc:MovieClip =zhengduobianxing(n,50)//实例化一个正多边形 mcc.filters =[new GlowFilter()] var v:Number=4;//每秒旋转地角度 var ang=0;//初始值多边形的旋转角度

mcc.addEventListener(Event.ENTER_FRAME ,frame); function frame(e) {

var vx:Number =len/(360/n)*v;//因为每旋转一个周期，中心点的角度改变是正多边形的一个圆心角

//x方向移动的是一个边长len ，所以根据比例len/正多边形的一个圆心角=vx/v //就可以求出x方向的速度vx

mcc.x=Math.min(Math.max(mcc.x+vx,0),550); //使正多边形左右运动的边界为0---550 mcc.x==0||mcc.x==550?v*=-1:0; //达到边界时反向运动

mcc.rotation=(180-360/n)/2+ang;//让多边形旋转起来

//注意因为开始为了正多边形的一条边水平放置已经旋转了个角度(180-360/n)/2 //所以此时开始旋转要把这个角度加上 ang+=v;//让旋转角度不停的增加

mcc.y=spline.y+r*Math.sin((-(90+180/n)+ang%(360/n))*Math.PI /180)

//因为每个正多边形的中心相对于水平边右下角边的点的角度是-(90+180/n)，而旋转角度一直的范围是0到一个中心角变化

//所以用(-(90+180/n)+ang%(360/n)表示正多边形的中心每时刻的的角度再用圆的参数方程即可，

//此时的圆心为右下角的点在水平线上，所以再加上spline.y } }

实例24 杨辉三角课件

hangshutxt.restrict=\"0123456789\";//只能输入数字

var ceng:int;//生成杨辉三角的层数注意不要赋值在下面的函数体里赋值 var sp:Sprite =new Sprite();//用来盛放数字的容器方便将来清空 addChild(sp); sp.x=0; sp.y=0;

//输入文字添加改变函数

hangshutxt.addEventListener(Event.CHANGE ,f); function f(e) {

yanghuisanjiao();//调用杨辉三角函数

}

//定义一个文本函数

function shuzi(txt:int,xx:Number ,yy:Number ):TextField { var wenzi:TextField =new TextField(); sp.addChild(wenzi);

var txtF:TextFormat =new TextFormat(); txtF.bold=true;

txtF.color=0x00ffff; txtF.font=\"隶书\"; txtF.size=30;

wenzi.defaultTextFormat=txtF; wenzi.text=String(txt);

wenzi.filters=[new BevelFilter ,new GlowFilter ]; wenzi.x=xx; wenzi.y=yy; return wenzi; }

// 创建一个二维数组用来保存杨辉三角 var arr:Array=[];

//用for嵌套循环为杨辉三角的每一层创建个二维空数组 function yanghuisanjiao() {

for (var k:int=sp.numChildren -1; k>=0; k--) {//每次改变数字前要把原来的情况 sp.removeChildAt(k); }

ceng=int(hangshutxt.text); for (var i=0; ifor (var j:int=0; j<=i; j++) {//第i层中一共有i+1个值因为是从0开始 if (i==0) {

arr[i][j]=1;//如果是第一行，则直接赋值为1

} else {//如果不是第一行则根据上一行的值计算当前行的每个元素的值 var shuzhi:int=0;//用来保存当前的数值

if (j>=1) {//因为j＝0时候，说明是每行的第一个值为1

//而≥1说明是每行1后面的数字如果右上角有数则加到shuzhi里 shuzhi+=arr[i-1][j-1]; }

if (j//两个if语句说明分别把左上角和右上角的数值加到shuzhi变量里得到当前的数 arr[i][j]=shuzhi; }

//trace(shuzhi)

i%2==0?shuzi(shuzhi,275-(i/2+0.5)*50+j*50,i*50):shuzi(shuzhi,275-(i+1)/2*50+j*50,i*50);

//当偶数行的时候第一个数的位置是从中心275向左i/2个再加上0.5个数字间距即（i/2+0.5）个数字间距开始的

//依次往右，当奇数行时则是从中间275的位置向左（i+1）/2数

字间距开始依次往右的。注意这是的i是从0开始的

//即第一行是i=0一次类推，如果设置的i开始=1，则情况相反 } } }

yanghuisanjiao();//先调用一次函数即显示默认数字情况的杨辉三角

实例25 不等式的解集演示课件

//场景中有个shuzhitxt和fuhaotxt文本框，可以拖动单位点改变刻度， var W:Number=stage.stageWidth; var H:Number=stage.stageHeight; var zhou:Sprite =new Sprite();

var yuandian:MovieClip =new Dian(); addChild(yuandian);

yuandian.buttonMode=true; //====原点

//yuandian.scaleX=yuandian.scaleY=2; yuandian.x=stage.stageWidth/2; yuandian.y=stage.stageHeight/2; //====单位点

var danweidian:MovieClip =new Dian(); addChild(danweidian); danweidian.y=H/2; danweidian.x=W/2+50;

danweidian.buttonMode=true;

//danweidian.scaleX=danweidian.scaleY=2; //=====轴线

graphics.lineStyle(2,0xffff00); graphics.moveTo(0, H/2); graphics.lineTo(W, H/2); var jt:MovieClip=new Jt(); //========箭头 addChild(jt);

jt.scaleX=jt.scaleY=0.5; jt.x=W-5;// jt.y=H/2;

//=====用来装每个小线段和数字的容器 var sp:Sprite =new Sprite(); addChild(sp);

//===给单位点添加鼠标按下事件

danweidian.addEventListener(MouseEvent.MOUSE_DOWN ,df); function df(e) {

for (var k:int =sp.numChildren -1; k>=0; k--) {//鼠标按下后清空容器 sp.removeChildAt(k);

}

var rect:Rectangle=new Rectangle(W/2,H/2,W,1); danweidian.startDrag(false,rect);//单位点开始拖动 }

//====给单位点添加抬起事件

stage.addEventListener(MouseEvent.MOUSE_UP ,upf); function upf(e) {

danweidian.stopDrag();//停止拖动 intf();//调用函数 }

//==========先调用一次 intf();

//=========数值输入文本改变值时添加函数 shuzhitxt.restrict=\"-0-9\";

fuhaotxt.restrict=\"><≥≤\";//限制两个文本框的输入对象 shuzhitxt.addEventListener(Event.CHANGE ,changf); //=========符号输入文本改变值时添加函数

fuhaotxt.addEventListener(Event.CHANGE ,changf); function changf(e) {

for (var k:int =sp.numChildren -1; k>=0; k--) {//清空容器 sp.removeChildAt(k); } intf(); }

//每个数字函数

function txtf(shuzi:Number,xx:Number ,yy:Number ) { var txt:TextField =new TextField(); sp.addChild(txt);

var txtF:TextFormat =new TextFormat(); txtF.bold=true;

txtF.color=0xffffff; txtF.size=20; txtF.align=\"left\";

txt.defaultTextFormat=txtF; txt.text=String(shuzi); txt.x=xx; txt.y=yy; }

//=======数字和小线段函数 function intf() {

var danweichangdu:Number=danweidian.x-W/2; var n:int=int(W/danweichangdu)/2;

for (var j:Number =W/2-n*danweichangdu; j<=W/2+n*danweichangdu; j+=danweichangdu) { //j代表每个数字

var mc:MovieClip =new MovieClip(); sp.addChild(mc);

//注意这里是从负的到正的增加，步长为一个单位长度

mc.graphics.clear();

mc.graphics.lineStyle(1,0xffffff); mc.graphics.moveTo(j,H/2); mc.graphics.lineTo(j,H/2-10);

txtf((j-W/2)/danweichangdu,j-10,H/2+10);//为了把数字放在相应刻度下面所以让y坐标+10

//让横坐标向左移动10个像素这是经验值可以改变

var dian:MovieClip =new MovieClip();//实例化一个x范围的点 sp.addChild(dian); var color:uint;

dian.graphics.lineStyle(2,0xffffff); dian.graphics.beginFill(color); dian.graphics.drawCircle(0,0,5); dian.y=H/2;

dian.x=W/2+Number(shuzhitxt.text)*danweichangdu; var mc1:MovieClip =new MovieClip(); sp.addChild(mc1); var newx:int;

if (fuhaotxt.text==\">\") {

//注意要把两个文本框的属性设置为单行 newx=W;

color=0x000000;

//当没有等号时候就用黑色填充的跟场景一个颜色就像一个空心圆的假象 }

if (fuhaotxt.text==\"<\") { color=0x000000; newx=0; }

if (fuhaotxt.text==\"\"||shuzhitxt.text==\"\") { sp.removeChild(mc1);

//当期中一个文本框没有数字时候就要范围的线要消失，否则没有这个限制时空字符串是会被默认为0值

sp.removeChild(dian); }

if (fuhaotxt.text==\"≥\") { newx=W;

color=0xffffff;//如果有等号则点用白色填充给人以实心圆的假象 }

if (fuhaotxt.text==\"≤\") { newx=0;

color=0xffffff;//如果有等号则点用白色填充给人以实心圆的假象 }

mc1.graphics.lineStyle(2,0xff00ff); mc1.graphics.moveTo(dian.x,dian.y); mc1.graphics.lineTo(dian.x,dian.y-50); mc1.graphics.lineTo(newx,dian.y-50); } }

实例26 圆在正多边形内部的滚动

var n:int=8;//多边形的边数 intf();

function intf() {

var sp:Sprite =new Sprite(); addChild(sp); sp.x=275; sp.y=200;

var len:Number=100;//正多边形的边长 var ang:Number=360/n;//正多边形的中心角

var h:Number=len/2/Math.tan(180/n*Math.PI/180);//正多边形的边心距 var R:Number=len/2/Math.sin(180/n*Math.PI/180);//外接圆半径

var r:Number=len/Math.PI/2;//滚动的小圆的半径保证一条边正好转动一周 //================下面的线段为了观察小圆运动的参考线 sp.graphics.lineStyle(6,0xff0000); sp.graphics.moveTo(-len/2,h); sp.graphics.lineTo(len/2,h); //===画小圆

var circle:MovieClip =new MovieClip(); sp.addChild(circle);

circle.graphics.lineStyle(3,0xffffff);

circle.graphics.drawCircle(0,0,r); circle.x=- len/2; circle.y=h+r+3;

var mcA:MovieClip =new Mca();//为了观察小圆的旋转情况添加一个字母A circle.addChild(mcA); mcA.x=0; mcA.y=- r;

//===进入场景小圆旋转，并且前进

stage.addEventListener(Event.ENTER_FRAME ,f1); function f1(e) { circle.x++;

circle.rotation-=360/len;

if (circle.x==len/2) {//当走到最右端点是让小圆做弧线运动 sp.addEventListener(Event.ENTER_FRAME,f)

//每当小球走到该边的右端时就让容器即小球和该红线段旋转，这要就造成小球绕周边旋转的假象 } }

//============

var i:int=1;//控制旋转中心角的倍数 function f(e) {//容器旋转地 circle.x=- len/2; sp.rotation=- i*ang; i++;

sp.removeEventListener(Event.ENTER_FRAME ,f);//旋转一次后就删除该帧频函数 }

//=========画场景中的正多边形 var zdbx:Shape =new Shape(); addChild(zdbx);

zdbx.graphics.lineStyle(3,0xffffff);

zdbx.graphics.moveTo(sp.x+len/2,sp.y+h+2*r+3);//保证最下边总是水平，并且从它的右端点开始画线

var Ang:Number=Math.atan2(h,+ len/2);//再算出该点的角度因为要在此 基础上循环增加若干个正多边形的中心角 //trace(Ang*180/Math.PI ) for (var k:int =0; k<=n; k++) {

zdbx.graphics.lineTo(sp.x+(R+2*r+3+3)*Math.cos (k*ang*Math.PI /180+Ang),sp.y+(R+2*r+3+3)*Math.sin (k*ang*Math.PI /180+Ang));

//注意角度都要加上开始的基础角度因为小圆和红线的线条粗细是3所以再加上两个3个像素 } }

setChildIndex(addbtn,0); setChildIndex(subbtn,1);

addbtn.addEventListener(MouseEvent.MOUSE_DOWN ,df); subbtn.addEventListener(MouseEvent.MOUSE_DOWN ,df); function df(e) {

while (numChildren>2) { removeChildAt(2); }

e.target.name==\"addbtn\"?n++:n--; intf(); }

实例27 文字特效—三叶玫瑰线

var b:int =3; var cycle:int;

b%2==0?cycle=360:cycle=180; var w0=0; var a=180;

var difference:int=6; var j=0;

var sp:Sprite=new Sprite(); addChild(sp); sp.x=275; sp.y=200;

var txt=\"三叶草平安qq825010428\"; var r=15;//小球半径

var matrix:Matrix=new Matrix();

matrix.createGradientBox(2*r,2*r,0,-r,-r); var format:TextFormat=new TextFormat (); format.align=TextFormatAlign.CENTER; format.color=0xffffff; format.size=20;

for (var i=0; ivar mc:MovieClip=new MovieClip();

mc.graphics.beginGradientFill(GradientType.RADIAL,[0xff0000,0x000000],[1,1],[0,255],matrix);

mc.graphics.drawCircle(0,0,r); mc.angl=0;

var t:TextField=new TextField (); t.type=\"dynamic\" ; t.width=28; t.height=24;

t.text=txt.charAt(txt.length-1-i); //t.text=txt.charAt(i) t.x=-14; t.y=-12;

t.setTextFormat(format); mc.addChild(t); sp.addChild(mc);

//sp.addChildAt(mc,0)

mc.x=a*Math.cos(b*mc.angl*Math.PI/180)*Math.cos(mc.angl*Math.PI/180); mc.y=a*Math.cos(b*mc.angl*Math.PI/180)*Math.sin(mc.angl*Math.PI/180); }

sp.graphics.lineStyle(2,0xffff00); sp.graphics.moveTo(a,0);

addEventListener(Event.ENTER_FRAME,f); var k:int=1;

function f(e:Event) {

if (w0<=cycle) {

var X=a*Math.cos(b*w0*Math.PI/180)*Math.cos(w0*Math.PI/180); var Y=a*Math.cos(b*w0*Math.PI/180)*Math.sin(w0*Math.PI/180); sp.graphics.lineTo(X,Y); w0++; } else {

for (var i=0; ivar mc=sp.getChildAt(sp.numChildren-1-i); mc.angl++;

mc.x=a*Math.cos(b*mc.angl*Math.PI/180)*Math.cos(mc.angl*Math.PI/180); mc.y=a*Math.cos(b*mc.angl*Math.PI/180)*Math.sin(mc.angl*Math.PI/180); mc.angl%=cycle; }

if (kj%difference==0?k++:0; } } }

实例28 文字特效—打字效果

var st:String=\"家人是太阳，朋友是月亮，晒晒太阳生活安康，看看月亮心情舒畅。亲情给太阳，友情给月亮。在阳光下温暖，在月光下凉爽。三叶草平安qq====825010428\"; txt.text=\" \";

var timer:Timer=new Timer(100,st.length+1);//有几个文字时间侦听器就执行几次根据文本框的长度确定然后加1 timer.start();

timer.addEventListener(TimerEvent.TIMER ,f); function f(e) {

txt.appendText(st.substr (timer.currentCount-1,1));//给文本框追加文字,追加的文字是截取的字符串中的文字，

//subsrt是截取属性参数是从第几个字开始截取，这里是从0开始的，二计时器运行次数是从一开始的因此要减去1，

//第二个参数值的是每次截取几个因为一个一个显示的所以为1 btn.addEventListener(MouseEvent.MOUSE_DOWN ,df); }

var t:Timer; function df(e) {

timer.reset();//计时器重新开始 timer.start(); txt.text=\" \"; }

实例29 下雨逼真涟漪

stage.frameRate=80;

var sound:Sound =new Sound();

var channel:SoundChannel=new SoundChannel(); var

url:String=\"http://zhangmenshiting.baidu.com/service/e699d55505b499f4b2e017879856d0e8.mp3?xcode=f12e445a8e027b84ed1b17f32ef293882f\"; var req:URLRequest=new URLRequest(url); sound.load(req)

channel=sound.play ()

function ellipse(X:Number,Y:Number ) {//涟漪函数 var mc:MovieClip =new MovieClip(); addChildAt(mc,1); mc.x=X; mc.y=Y;

mc.graphics.lineStyle(0.5,0xbbffff,0.6);

mc.graphics.drawEllipse(-1,-0.3,2,0.6); mc.graphics.endFill();

mc.addEventListener(Event.ENTER_FRAME ,f); var v0=0.5+0.3*Math.random(); function f(e) {

mc.scaleX=mc.scaleY+=v0; mc.alpha>0?mc.alpha

-=0.02:[mc.removeEventListener(Event.ENTER_FRAME ,f),removeChild(mc),mc=null] }}

function xiayu() {

var mc:MovieClip =new MovieClip(); mc.graphics.beginFill(0xbbffff,0.8);

mc.graphics.drawEllipse(-0.5,-2,2,5); addChildAt(mc,1);

mc.scaleX=mc.scaleY=0.7+0.3*Math.random(); var x0=mc.x=Math.random()*550; mc.y=-10-20*Math.random();

mc.addEventListener(Event.ENTER_FRAME ,xiayuf); var y0=300+250*Math.random(); function xiayuf(e) {

if (mc.ymc.removeEventListener(Event.ENTER_FRAME ,xiayuf); removeChild(mc); mc=null;

ellipse(x0,y0);//雨滴的纵坐标大于初始坐标就执行涟漪函数 } }}

var t:Timer=new Timer(50,0);//改时间侦听下雨，每50毫秒执行一次 t.addEventListener(TimerEvent.TIMER,onT); t.start();

function onT(e) {

xiayu();//调用下雨函数

}var vx=0.5;//人走动的水平方向的速度

san.addEventListener(Event.ENTER_FRAME ,ff); function ff(e) { san.x+=vx;

if (san.x>=550) { vx*=-1;

san.scaleX =-1//元件水平翻转//当人走到边界的时候要水平翻转所以用水平方向缩放值为-1即可 }

if (san.x<=0) { vx*=-1;

san.scaleX =1 }}

实例30 变换彩色效果

//圆的参数方程

[SWF(width=550,height=500,frameRate=30)] stage.frameRate=30; var px:Number; var py:Number; var angle:Number;

var R:Number=100;//外圆半径 var r:Number=30;//内圆半径 var i:int=0; var col:uint; var m:int=0;

var c:Object={r:-5,g:-5,b:-20}; var sp:Sprite=new Sprite(); sp.x=stage.stageWidth/2; sp.y=stage.stageHeight/2;

sp.graphics.lineStyle(1,0xffffff); //sp.filters=[new GlowFilter()] addChild(sp);

for (i=0; i<360*8; i++) { angle=i*Math.PI/180;

myrot();//圆的参数方程的自定义函数 if (i==0) {

sp.graphics.moveTo(px,py); } else {

sp.graphics.lineTo(px,py); } }

var ball:Ball=new Ball(); sp.addChild(ball);

ball.cacheAsBitmap=true;

//如果设置为 true，则 Flash Player 将缓存显示对象的内部位图表示形式。属性往往比默认使用矢量能够更快地呈现。 function myrot():Number {

px=(R+r)*Math.cos(angle)+r*Math.cos((R-r)/r*angle); py=(R+r)*Math.sin(angle)-r*Math.sin((R-r)/r*angle); return px; return py; }

//创建布林噪波位图

var map1:BitmapData=new BitmapData(550,500,false,0); var map2:BitmapData=new BitmapData(550,500,false,0); map2.perlinNoise(10,160,2,10,true,true,1,true); var perMc:Sprite=new Sprite();//装有杂点容器 var con1:Sprite=new Sprite();//父容器 var con:Sprite=new Sprite();//小容器 addChild(con);

使用该 con.addChild(sp);//装画的圆 con1.addChild(perMc);

var perBit:Bitmap=new Bitmap(map2); perMc.addChild(perBit);

addChild(new Bitmap(map1));//场景上的底图 var bit:Bitmap=new Bitmap(map2);

bit.blendMode=BlendMode.OVERLAY;//与底色<50%变暗 addEventListener(Event.ENTER_FRAME,frame); function frame(e):void { angle=i%720*Math.PI/180; myrot(); ball.x=px; ball.y=py; i+=2;

sp.rotation++;

map1.draw(con);//小圆环

map2.draw(con1);//有布林杂点的图

map1.applyFilter(map1,map1.rect,new Point(),new BlurFilter(2,2,1)); map1.colorTransform(map1.rect,new ColorTransform(1,1,1,1,c.r,c.g,c.b)); map1.draw(map1.clone(),new Matrix(1,0,0,1,0,-2)); m++;

switch (m%300) { case 50 : c.g=c.b; break; case 100 :

c.r=c.b,c.g=c.b=-5; break; case 150 : c.b=-20; break; case 200 :

c.g=-20,c.r=c.b=-5; break; case 250 : c.r=c.g; break; case 0 :

c.r=c.g=-5,c.b=-20; break; } }

setChildIndex(mc,numChildren-1)

实例31 变换的曲线

////==============画椭圆

var spr:Sprite =new Sprite(); var mcarr:Array=[]; addChild(spr); spr.x=275; spr.y=200; var num=72;// var R:Number=100; var r:Number=60;

var R0:Number=150;//椭圆的长半轴和短半轴 var r0:Number=56;

function drawEllip(a,b):Sprite {

var mc:Sprite =new Sprite();//容器类没有私有属性，而movieclip类可以定义私有属性 var col:uint=0xffffff*Math.random(); var g:Graphics=mc.graphics; g.lineStyle(1,col);

g.drawEllipse(-a,-b,2*R0,2*r0); addChild(mc); return mc;}

//drawEllip(R0,r0); var k:Number=0;

var t:Timer=new Timer(50,72); var t2:Timer=new Timer(5); t.start();

t.addEventListener(TimerEvent.TIMER ,f); function f(e) {

var mc:Sprite=drawEllip(R0,r0); //mc.filters=[new DropShadowFilter() ];

//mc.filters=[new GlowFilter(0xff0000)]; spr.addChild(mc); mcarr.push(mc);

var ang=5;//因为总共三六十度72个椭圆所以360/72=5 mc.rotation=k*5;

mc.x=R*Math.cos(k*ang*Math.PI/180);//这七十二个椭圆的中心轨迹在另一个椭圆的的圆周上

mc.y=r*Math.sin(k*ang*Math.PI/180); k++;

k==72?addEventListener(Event.ENTER_FRAME,ff):0; function ff(e) {

var mc=e.target;

mc.alpha=Math.random(); t2.start(); }}

t2.addEventListener(TimerEvent.TIMER ,ff); var n:Number=0; function ff(e) {

var mc:Sprite=mcarr[n%72];

var tran:ColorTransform =new ColorTransform(); var m:uint=0xffffff*Math.random();

if (n%72==0) {

for (var j:int=0; j实例32 图片颜色改变

import fl.transitions.Tween //下面用到了缓动类，所以先导入这个类

import fl.transitions.easing.Bounce //Bounce：在一个或两个结束点过渡范围内加入回弹效果

//===========点击场景颜色循环改变 var n:uint=0;//颜色变换次数

var ofsetArr:Array=[];//改变颜色的二维数组

ofsetArr[0]=[-1,-1,1,1,255,255,0,0];//参数1、2、3分别是红绿蓝色三个通道值-1说明是削弱该颜色的值1说明是百分百显示该颜色值，

//参数4透明度，参数5。6.7分别是红绿蓝的偏移值参数8是透明度 ofsetArr[1]=[-1,1,-1,1,90,0,0,0]; ofsetArr[2]=[1,1,-1,1,0,90,0,0];

ofsetArr[3]=[-1,-1,-1,1,145,180,0,0];

ofsetArr[4]=[1,1,1,1,0,0,0,0];//回到原来的颜色 var color:ColorTransform;

_mc.addEventListener(MouseEvent.MOUSE_DOWN ,downf); _mc.buttonMode=true;//显示手型 function downf(e) { var len:uint=ofsetArr.length;

switch (n%5) {//四中颜色循环出现 case 0 :

color=setColorTransform(ofsetArr[0]); break; case 1 :

color=setColorTransform(ofsetArr[1]); break; case 2 :

color=setColorTransform(ofsetArr[2]); break; case 3 :

color=setColorTransform(ofsetArr[3]); break; case 4 :

color=setColorTransform(ofsetArr[4]); break; } n++;

e.target.transform.colorTransform=color;

var tween:Tween=new Tween(_mc,\"alpha\缓动参数：对象，类型：透明度，反弹退出，透明度的缓动范围0到1，间隔时间为1，true表示单位是秒否则false为1帧 }

function setColorTransform(arr:Array ):ColorTransform { return new

ColorTransform(arr[0],arr[1],arr[3],arr[4],arr[5],arr[5],arr[7],arr[8]); }

//===========效果2，颜色随鼠标改变

_mc.addEventListener (MouseEvent.MOUSE_MOVE,setcolorf) function setcolorf(e){

var trans:ColorTransform =_mc.transform .colorTransform

trans.redMultiplier =_mc.mouseX /_mc.width //红色和绿色的值随着鼠标的位置改变而改变

trans.blueMultiplier =_mc.mouseY /_mc.height _mc.transform .colorTransform=trans }

实例33 闪闪的红星

function drawline():Sprite { var lines:Sprite =new Sprite(); addChild(lines); lines.x=275; lines.y=200;

for (var i:int =0; i<360; i+=3) { var sp:Sprite =new Sprite();

sp.graphics.beginFill(0xffff00*Math.random ()+5,1); sp.graphics.drawRect(0,-30,550,5); sp.graphics.endFill(); addChild(sp); sp.rotation=i*3; lines.addChild(sp); }

return lines; }

var backline:Sprite =new Sprite(); backline=drawline();

//这两种调用函数的方式都可以 var maskline:Sprite=drawline(); maskline.scaleX=-1; backline.mask=maskline;

maskline.addEventListener(Event.ENTER_FRAME ,f); function f(e) { e.target.rotation+=10; //maskline.rotation +=3 }

var pentacle:Pentacle=new Pentacle(); addChild(pentacle);

pentacle.x=275; pentacle.y=200;

pentacle.rotation=36;

实例34 文字特效--星星文字

Var url:URLRequest=new

URLRequest(\"http://opus.mvbox.cn/music/yc/09/12/28/09122817132421.mp3\"); var yy:Sound=new Sound(url);

var ch:SoundChannel=new SoundChannel(); ch=yy.play();

[SWF(backgroundColor=0x990000)]//0颜色为黑色 function star():Shape { var sh:Shape =new Shape(); addChild(sh);

sh.graphics.beginFill(0xffff00); var r:Number;

sh.graphics.moveTo(4,0);

for (var i:int=0; i<10; i++) { i%2==0?r=1.5:r=4;

var a:Number=r*Math.cos ((i+1)*Math.PI /5);

var b:Number=r*Math.sin ((i+1)*Math.PI /5); sh.graphics.lineTo(a,b); }

addEventListener(Event.ENTER_FRAME ,f); function f(e) {

sh.transform .colorTransform=new ColorTransform(1,1,1,1,Math.random() *510-600,Math.random() *510-255,Math.random() *510-255,0) }

return sh; }

var sp:Sprite=new Sprite ; addChild(sp);

for (var i:int=0; i<50; i++) { for (var j:int=0; j<10; j++) { var sta:Shape=star(); sp.addChild(sta); sta.x=i*8; sta.y=j*8 } }

sp.x=stage.stageWidth/2-sp.width/2+sta.width/2; sp.y=40;

var txt:TextField=new TextField();

txt.defaultTextFormat=new TextFormat(\"黑体xt.width=sp.width; txt.height=sp.height; var spziti:Sprite;

function txtMask(str:String =\"\") { txt.text=str;

var bmd:BitmapData=new BitmapData(sp.width,sp.height,true,0x00000000); var bmp:Bitmap=new Bitmap(bmd); spziti=new Sprite(); addChild(spziti);

spziti.addChild(bmp); bmd.draw(txt);

spziti.x=sp.x-sta.width/2; spziti.y=sp.y-sta.height/2; spziti.cacheAsBitmap=true; sp.cacheAsBitmap=true; sp.mask =spziti }

txtMask(\" 三叶草平安qq825010428\");

实例36 文字特效—散开组合

var mc:MovieClip =new Mc();//库中有个写有文字的类文件 //因为该影片加载后并没有添加的显示列表里

//所以系统背后默认为在场景中的左上角，并且是中心对齐 var arrmap:Array=[]; var arrx:Array=[]; var arry:Array=[];

for (var i:int =0; i<25; i++) { for (var j:int =0; j<25; j++) {

var pic:BitmapData=new BitmapData(mc.width/25,mc.width/25,true,0); var matrix:Matrix=new

Matrix(1,0,0,1,mc.width/2-i*mc.width/25,mc.height/2-j*mc.width/25);//以及缩放的1也是先对原位图进行的变换

//所以拍照的矩阵的xy方向上的偏移量指的是被拍照的对象的设置，因为拍照时候默认是即400从左上角为位图（0,0）开始拍照的 //所以只能拍照元件的左下部分，因此要想拍照完整的部分要把圆对象向右即500和向下平移后才可以

var rect:Rectangle=new Rectangle(0,0,mc.width/25,mc.width/25);//这个矩形则是拍照好的位图的大小相当于对象的裁剪

var color:ColorTransform =new ColorTransform(); //color则可以改变原来对象的颜色

pic.draw(mc,matrix,color,null,rect,false); var map:Bitmap=new Bitmap(pic); addChild(map); map.scaleX=0.5; map.scaleY=0.5; arrmap.push(map);

map.y=-100*Math.random(); map.x=100+i*mc.width/25;

var yy:Number=100+j*mc.width/25; var xx:Number=100+i*mc.width/25; arrx.push(xx);

arry.push(yy); } }

stage.addEventListener(Event.ENTER_FRAME ,f); stage.addEventListener(MouseEvent.CLICK ,clf); function f(e) {

for (var k:int =0; kmc.filters =[new GlowFilter(),new BevelFilter()]; mc.transform.colorTransform=color; color.color=0xffffff*Math.random(); } }

function clf(e) {

for (var k:int =0; kmc.x+=(arrx[k]-mc.x)/5*Math.random (); mc.y+=(arry[k]-mc.y)/5*Math.random (); mc.filters =[new GlowFilter(),new BevelFilter()]; mc.transform.colorTransform=color; color.color=0xffffff*Math.random(); } }

实例37 文字特效—一个文字围绕另一文字旋转 //场景中有两个文字原件，ping和an

ping.buttonMode=true; an.buttonMode=true;

ping.addEventListener(MouseEvent.CLICK ,pingf); an.addEventListener(MouseEvent.CLICK ,anf); var ang:Number=Math.PI;

function pingf(e:MouseEvent) {

removeEventListener(Event.ENTER_FRAME ,f2) addEventListener(Event.ENTER_FRAME ,f1); }

function f1(e:Event):void {

ping.removeEventListener(MouseEvent.CLICK ,pingf); an.addEventListener(MouseEvent.CLICK ,anf); an.x=ping.x+100*Math.cos(ang); an.y=ping.y+100*Math.sin(ang); ang+=0.05 ; }

function anf(e:MouseEvent):void {

ping.addEventListener(MouseEvent.CLICK ,pingf);

an.removeEventListener(MouseEvent.CLICK ,pingf); addEventListener(Event.ENTER_FRAME ,f2); }

function f2(e:Event) {

removeEventListener(Event.ENTER_FRAME ,f1) ping.x=an.x+100*Math.cos(ang); ping.y=an.y+100*Math.sin(ang); ang+=0.05; }

实例38 文字特效—文字转圈

var angle:Number=0;

var rx:Number=250;//x轴的半径 var ry:Number=100;//y轴的半径 var speed:Number=3; //字体旋转地速度

var arr:Array=[\"三\叶\草\平\安

\for (var i:int=0; ivar sp:Sprite=movef(arr[i],i*360/arr.length);//该函数有两个参数，一个是文字，和旋转角度 sp.x=0;

addChild(sp); }

function movef(str:String ,angle:Number =0):Sprite {angle-=speed; var sp:Sprite =new Sprite();

var txt:TextField =new TextField();

txt.defaultTextFormat=new TextFormat(\"华文行楷xt.filters=[new BevelFilter(6,45,0xffffff,1,0,1,5,5,1,1,\"inner\ txt.text=str;

sp.addChild(txt);

addEventListener(Event.ENTER_FRAME ,ff); function ff(e) {

sp.x=250+rx*Math.cos(angle*Math.PI/180); sp.y=200+ry*Math.sin(angle*Math.PI/180); angle-=speed; }

return sp;

}//注意有初始值的一定要在没有初始值的后面

实例39 文字特效—手写火焰字效果

//=================完成写字效果 var sp:Sprite =new Sprite(); //addChild(sp);

stage.addEventListener(MouseEvent.MOUSE_DOWN ,down); function down(e) {

if (e.target!=btn) {//这句判断为了防止鼠标放在按钮上画线：如果当前目标不等于按钮时

画线

sp.graphics.lineStyle(5,0xffff00);

sp.graphics.moveTo(mouseX,mouseY);

stage.addEventListener(MouseEvent.MOUSE_MOVE,movef); stage.addEventListener(MouseEvent.MOUSE_UP,upf);

stage.removeEventListener(MouseEvent.MOUSE_DOWN ,down); } }

function movef(e) {

sp.graphics.lineTo(mouseX,mouseY); }

function upf(e) {

stage.removeEventListener(MouseEvent.MOUSE_MOVE,movef); stage.removeEventListener(MouseEvent.MOUSE_UP,upf); stage.addEventListener(MouseEvent.MOUSE_DOWN ,down); }

btn.addEventListener(MouseEvent.MOUSE_DOWN ,shanchu); function shanchu(e) { sp.graphics.clear(); }

//======下面是火焰效果

var map:BitmapData=new BitmapData(550,400,false,0);

map.perlinNoise(15,40,3,10,true,true,1,true);//15，40代表xy方向的值，3是层数，true表哈斯缝合，true表示碎片的噪声，10 是随机总数，1代表红色，true代表红绿蓝相同的值

var mc:Sprite =new Sprite(); //addChild(mc)

var mapmc:Sprite =new Sprite(); mc.addChild(mapmc);

for (var i=0; i<3; i++) {

var mapbit:Bitmap=new Bitmap(map); mapmc.addChild(mapbit); mapbit.y=i*400 ;}

var mapz:BitmapData=new BitmapData(550,400,false,0); var mapb:BitmapData=new BitmapData(550,400,false,0); addChild(new Bitmap(mapz));

var bit:Bitmap=new Bitmap(mapb); addChild(bit);

bit.blendMode=BlendMode.OVERLAY;//混合模式 addEventListener(Event.ENTER_FRAME ,frame); function frame(e) { mapz.draw(sp); mapb.draw(mc);

mapz.applyFilter (mapz,mapz.rect ,new Point(),new BlurFilter(2,2,1))

mapz.colorTransform (mapz.rect ,new ColorTransform(1,1,0.5,1,-5,-20,-20)) mapz.draw (mapz.clone (),new Matrix(1,0,0,1,0,-2))

mapmc.y>-800?(mapmc.y-=5,mapmc.x+=Math.random ()*10-5):(mapmc.y=0,mapmc.x=0)

}

addChild(btn)没有初始值的后面

实例40 文字特效—下落的星星文字

//draw还有个参数可用就是fillrect来设置填充方式 var mc:MovieClip =new Mc();

//因为该影片加载后并没有添加的显示列表里

//所以系统背后默认为在场景中的左上角，并且是中心对齐 var arrmap:Array=[]; var arrx:Array=[]; var arry:Array=[];

for (var i:int =0; i<25; i++) { for (var j:int =0; j<25; j++) {

var pic:BitmapData=new BitmapData(mc.width/25,mc.width/25,true,0); var matrix:Matrix=new

Matrix(1,0,0,1,mc.width/2-i*mc.width/25,mc.height/2-j*mc.width/25);//以及缩放的1也是先对原位图进行的变换

//所以拍照的矩阵的xy方向上的偏移量指的是被拍照的对象的设置，因为拍照时候默认是即400从左上角为位图（0,0）开始拍照的 //所以只能拍照元件的左下部分，因此要想拍照完整的部分要把圆对象向右即500和向下平移后才可以

var rect:Rectangle=new Rectangle(0,0,mc.width/25,mc.width/25);//这个矩形则是拍照好的位图的大小相当于对象的裁剪

var color:ColorTransform =new ColorTransform(); //color则可以改变原来对象的颜色 pic.draw(mc,matrix,color,null,rect,false); var map:Bitmap=new Bitmap(pic); addChild(map); map.scaleX=0.5; map.scaleY=0.5; arrmap.push(map);

map.y=-100*Math.random(); map.x=100+i*mc.width/25;

var yy:Number=100+j*mc.width/25; var xx:Number=100+i*mc.width/25; arrx.push(xx); arry.push(yy); } }

stage.addEventListener(Event.ENTER_FRAME ,f); stage.addEventListener(MouseEvent.CLICK ,clf); function f(e) {

for (var k:int =0; kmc.y+=(arry[k]-mc.y)/10;

mc.filters =[new GlowFilter(),new BevelFilter()]; mc.transform.colorTransform=color; color.color=0xffffff*Math.random(); } }

function clf(e) {

for (var k:int =0; kmc.x+=(arrx[k]-mc.x)/5*Math.random (); mc.y+=(arry[k]-mc.y)/5*Math.random (); mc.filters =[new GlowFilter(),new BevelFilter()]; mc.transform.colorTransform=color; color.color=0xffffff*Math.random(); } }

实例41 动画效果打开的羽毛扇

var j:int=0,k:int=1; var arr:Array=[];

for (var i:int =0; i<18; i++) { var mc:Mc=new Mc(); addChild(mc); mc.x=275; mc.y=300;

mc.i=i-1;//自定义一个自由属性 mc.scaleX=mc.scaleY=0.5 mc.rotation=5

i>0?arr.push (mc):0//因为第一页羽毛不动时从第二页羽毛开始打开的所以从第二页羽毛才添加到数组中控制 }

addEventListener(Event.ENTER_FRAME ,f) function f(e){

for(var i:int =0;ij%(arr.length *5)/5>=arr[i].i?arr[i].rotation+=2*k:0 } j++

j%(arr.length *10)实例42 霓虹灯字体滚动效果

[SWF(width=\"550\var frameCount:int=-100;

var txt:TextField =new TextField(); txt.autoSize=TextFieldAutoSize.LEFT;

txt.background=true; txt.backgroundColor=0;

txt.text=\"河南滑县崔仙霞qq825010428\"; var format:TextFormat = new TextFormat(); format.color=0xffff00; format.size=30;

format.letterSpacing=1; txt.setTextFormat(format);

var bid:BitmapData=new BitmapData(txt.width,txt.height); bid.draw(txt);

addEventListener(Event.ENTER_FRAME, frame); function frame(event:Event):void { frameCount+=1;

if (frameCount>bid.width) { frameCount=-100; }

graphics.clear();

for (var y:int = 20; y <60; y++) { for (var x:int = 0; x < 111; x++) { var pixel:uint;

if (x+frameCount<0||x+frameCount>bid.width-1) { pixel=0; } else {

//设置字的坐标

pixel=bid.getPixel(x+frameCount,y-22); }

var m:Number=0+x*5; var n:Number=0+y*5; if (pixel!=0) {

//设置字显示的高亮部分(即字的前背景) drawDot(m, n, 2.5, 0xCC0000, 0xEFFBBF); } else {

//设置场景点的前背景

drawDot(m, n, 2.5, 0xFF6600, 0x800000); } } } }

function drawDot(x:Number, y:Number, size:Number, colorLight:uint, colorDark:uint):void {

var colors:Array=[colorLight,colorDark]; var alphas:Array=[1.0,1.0]; var ratios:Array=[0,255];

var matrix:Matrix = new Matrix();

matrix.createGradientBox(size * 2,size * 2,0,x - size,y - size); //graphics.lineStyle();

graphics.beginGradientFill(GradientType.RADIAL,colors,alphas,ratios,matrix); graphics.drawCircle(x, y, size); graphics.endFill(); } ///

var bmd:BitmapData=new Pic(0,0); var bm:Bitmap=new Bitmap(bmd); bm.blendMode=BlendMode.SCREEN;

//BlendMode 类的一个值，指定 Flash Player 如何将显示对象的颜色与下面的图形进行混合。[静态] 将显示对象颜色的补色（反色）与背景颜色的补色相乘，会产生漂白效果。

addChild(bm);

实例43 全脚本燃烧的蜡烛

//====光晕的效果

var cir:Sprite =new Sprite(); addChild(cir); cir.x=275; cir.y=80;

var mmm:Matrix =new Matrix();

mmm.createGradientBox(400,400,0,-200,-200);

cir.graphics.beginGradientFill(GradientType.RADIAL ,[0xffff99,0],[1,0],[0,255],mmm);

cir.graphics.drawCircle(0,0,300);

cir.addEventListener(Event.ENTER_FRAME ,ff); var vs:Number=0.05; function ff(e) {

e.target.scaleX=e.target.scaleY+=vs;

e.target.scaleX<0.1?[e.target.scaleX=0.1,vs=- vs]:0; e.target.scaleX>0.5?[e.target.scaleX=0.5,vs=-vs]:0 ; }

var candle:Sprite =new Sprite(); addChild(candle); candle.x=275; candle.y=270;

var m:Matrix=new Matrix();//实例化一个矩阵

m.createGradientBox(80,400,Math.PI /2,0,-200);//矩阵的填充渐变填充，宽80高高400因为默认的填充方式是从左到右的，二蜡烛是从上到下的所以旋转90x方向不偏移y方向偏移-200

candle.graphics.beginGradientFill(GradientType.LINEAR ,[0xffcccc,0xfebcbc,0xfe9a9a,0xff0000],[1,1,1,1],[0,18,36,255],m);

//第三个数组的值分别是第二个参数中的颜色值的透明度

candle.graphics.drawRoundRect(-40,-200,80,400,15,15);//说明矩阵的中心店为注册点参数为坐标和宽高，圆角程度

candle.graphics.beginFill(0xffffff,0.1);

candle.graphics.drawRect(-10,-150,30,300);//中间的透明矩形

candle.scaleX=candle.scaleY=0.6; candle.filters=[new

DropShadowFilter(20,275,0x000000,1,20,20,1.3,2,true)];///添加投影滤镜距离，角度,颜色，alpha值，x.y方向的模糊true为是否内侧投影

candle.transform.colorTransform=new ColorTransform(1,1,1,1,255,0,0,0);//设置颜色值前四个是红绿蓝的值和alpha值1,表示为默认值后四个分别为前四个的偏移值 //===============上面是蜡烛

function firemc():Sprite {//fire是火的意思

var fireside:Number=50;//定义一个火的边长即直径变量 var fire:Sprite =new Sprite(); addChild(fire);

var mm:Matrix=new Matrix();

mm.createGradientBox(fireside,fireside,0,-fireside/2,-fireside/2);

fire.graphics.beginGradientFill(GradientType.RADIAL ,[0xfffffcc,0xffcc00,0xff0000],[0.5,0.3,0],[0,100,255],mm);//参数：放射性，三个颜色值，三个颜色值的透明度，三个颜色值的偏移值，矩阵 fire.graphics.drawCircle(0,0,fireside/2); return fire; }

//=========上面的函数式画圆的下面的是让圆运动起来形成火燃烧 function firemove():Sprite { var fire:Sprite=firemc();

fire.blendMode=\"add\";//设置混合模式，add表示所有火球的颜色都和背景颜色混合 fire.addEventListener(Event.ENTER_FRAME ,onfire); function onfire(e) { fire.y-=6;

fire.x+=Math.random()*4-2; fire.alpha-=0.05;

fire.scaleX=fire.scaleY-=0.001; if (alpha<=0.005) {

fire.removeEventListener(Event.ENTER_FRAME ,onfire); removeChild(fire); fire=null ;} }

return fire; }

addEventListener(Event.ENTER_FRAME ,onfiremove); function onfiremove(e) { var fire:Sprite=firemove(); fire.x=275; fire.y=130; }

//=======画灯线

var rush:Sprite =new Sprite(); addChild(rush);

rush.graphics.lineStyle(2,0xffffff); rush.graphics.moveTo(275,130);

rush.graphics.curveTo(270,175,275,120); //=======蜡烛明暗变化 var va:Number=0.02;

candle.addEventListener(Event.ENTER_FRAME ,f); function f(e):void { e.target.alpha-=va; if (e.target.alpha<0.9) { e.target.alpha=0.9; va*=-1;}

if (e.target.alpha>1) { e.target.alpha=1; va*=-1; } }

第三章 动画特效一种方块遮罩效果

//导入缓动类和缓冲函数

import fl.transitions.Tween; import fl.transitions.easing.*; //定义正方形的高和宽 var boxWidth:Number=40; var boxHeight:Number=40;

//定义一共九行每行十四个正方形 var rows:Number=9;

var columns:Number=14;

//把所有的正方形都放在该数组中

var rectangles:Array = new Array(); //定义一个数组存放缓动

var tweens:Array = new Array(); //定义一个容器

var container:Sprite = new Sprite();

addChild(container);//存放正方形的容器遮罩图片 cityMC.mask=container;//实例化九行十四列正方形 for (var i=0; i < rows; i++) { for (var j=0; j < columns; j++) {

var maskRectangle:MaskRectangle = new MaskRectangle(); //每个小正方形的坐标

maskRectangle.x=j*boxWidth; maskRectangle.y=i*boxWidth; //每个小正方形的横向缩放为0 maskRectangle.scaleX=0; maskRectangle.scaleY=0; maskRectangle.alpha=0; //添加到容器中

container.addChild(maskRectangle);

//并且把每个小正方形添加到数组中方便调用 rectangles.push(maskRectangle); } }

//添加时间媜听

var timer=new Timer(35,rectangles.length);//每隔35毫秒，执行的次数等于矩形数组的长度即总共的

timer.addEventListener(TimerEvent.TIMER, animateMask); timer.start();

//自定义动画绘制函数

function animateMask(e:Event):void {

//找到当前的正方形//时间当前帧减去一的索引值因为数组中的索引值是从0开始 var rectangle=rectangles[timer.currentCount-1]; //给正方形的横向缩放添加缓动类 var scalexTween:Tween=new

Tween(rectangle,\"scaleX\ var scaleyTween:Tween=new

Tween(rectangle,\"scaleY\

var alphaTween:Tween=new Tween(rectangle,\"alpha\ tweens.push(scalexTween); tweens.push(scaleyTween); }

第三章 动画特效烟花效果

var map:BitmapData=new BitmapData(550,400,false,0x000000);//给一个黑色位图背景

var bit:Bitmap=new Bitmap(map); addChild(bit);

var arr:Array=[],m:int=0;//用m的逐渐增加来控制烟花出现的时间 function init() {

var color:uint=0xff0000*Math.random();

var starx:Number=25+500*Math.random();//烟花出来时的位置 var stary:Number=50+150*Math.random();

var num:int=30+Math.random()*20;//烟花的离子束 for (var j:int=0; jvar v=Math.random()*10;//烟花初始的时候各个例子所在的圆周半径是10以内的随机数 var a=Math.PI/num*2*j;//b把每一束烟花分散在一个圆周上单位是弧度

for (var i:int=0; ivar p:Point=new Point(starx,stary);//记录开始的位置点

if (Math.random()<0.6) {//如果随机的颜色小于0.6*白色那么较深， var cc:uint=color; } else {

cc=0xff0000; }

arr.push([xx,yy,v*Math.cos (a),v*Math.sin (a),cc,p]);//为了下面调用数据方便因此把xy和相应方向上的加速度和颜色值以及点的位置记录下来存放到arr中 } }

}var cf:ConvolutionFilter =new

ConvolutionFilter(3,3,[1,1,1,1,32,1,1,1,1],42)//声明一个卷曲滤镜 addEventListener(Event.ENTER_FRAME ,f); function f(e) { m++%50==0?init():0;

for (var i:int=0; imap.setPixel(arr[i][0],arr[i][1],arr[i][4]);//第一个参数为x坐标，即数组中的0号元素，第二个参数为y坐标即数组中的1号元素，第三个参数为颜色，即数组中的四号元素

arr[i][0]+=arr[i][2]*Math.random()/3; arr[i][1]+=arr[i][3]*Math.random()/3;

if (Math.random()>0.6) {//让y方向上的加速度增大下落 arr[i][3]+=Math.random ()/3 }

var b:Boolean=Point.distance(new Point(arr[i][0],arr[i][1]),arr[i][5])>80;//如果例子下落的位置与原来出来的中心位置距离超过80则该布尔值为真

var bb:Boolean =(Math.abs (arr[i][2])+Math.abs (arr[i][3]))<2;//如果x和y方向的加速度绝对值和小于2，说明下落的速度已经很慢则为真

if(b||bb&&Math.random ()>0.9){//再加上一个条件随机值大于0.9是为了例子慢速的移除因为此时已经是白色了

arr.splice (i,1)//从i号索引值移除一个离子 } }

map.applyFilter (map,map.rect ,new Point,cf)//位图添加滤镜参数为：对象即位图本身，范围即位图自身矩阵，点，滤镜类型 }

bit.blendMode =BlendMode.SCREEN//添加位图的混合模式，这样就可以显示图片背景了

第三章 动画特效绳子的弹跳运动

//画圆函数

var color=0xffffff*Math.random();

function circle(xx:Number ,yy:Number ,r):MovieClip { var mc:MovieClip =new MovieClip(); addChild(mc);

mc.filters =[new GlowFilter(),new BevelFilter()]; mc.x=xx; mc.y=yy;

mc.graphics.lineStyle(3,0xffffff); var matrix:Matrix =new Matrix();

matrix.createGradientBox(2*r,2*r,0,-r,-r);

mc.graphics.beginGradientFill(GradientType.RADIAL ,[color,0xffffff],[1,1],[0,255],matrix);

mc.graphics.drawCircle(0,0,r); return mc; }

//=======画两个端点

var circle1:MovieClip=circle(10,100,5); circle1.buttonMode=true;

var circle2:MovieClip=circle(500,100,5); circle2.buttonMode=true;

circle1.addEventListener(MouseEvent.MOUSE_DOWN ,df1); function df1(e) {

circle1.startDrag(false,new Rectangle(10,100,400,2)); }

circle2.addEventListener(MouseEvent.MOUSE_DOWN ,df2); function df2(e) {

circle2.startDrag(false,new Rectangle(10,100,500,2)); }

stage.addEventListener(MouseEvent.MOUSE_UP ,upf); function upf(e) { circle2.stopDrag(); circle1.stopDrag(); }

//====画一个较大的圆 var

mccir:MovieClip=circle(circle1.x+50+Math.random(),circle1.y+150*Math.random(),25);

var vx=1;//圆前进的速度

var ang:Number=0;//控制正弦曲线的参数 addEventListener( Event.ENTER_FRAME ,f); function f(e) {

color=0xffffff*Math.random()

mccir.x=Math.min(Math.max(mccir.x+vx,circle1.x+50),circle2.x-50);//限制圆的运动左右范围

//10+50是左端横坐标加圆半径，550-50是右端减去半径保证整个圆在两个端点之间 mccir.x==circle1.x+50||mccir.x==circle2.x-50?vx*=-1:0;//横坐标运动到边界反响 mccir.y=100+100*Math.sin(ang*Math.PI/180);//纵坐标做正弦曲线运动 ang+=3;//参数增加

mccir.rotation+=10;//圆同时自传 //计算圆心到两个端点的距离

var d1:Number=Point.distance(new Point(mccir.x,mccir.y),new Point(circle2.x,circle2.y));//两个端点到圆形的距离

var d2:Number=Point.distance(new Point(mccir.x,mccir.y),new Point(circle1.x,circle1.y));

var d3:Number=Math.sqrt(d2*d2-25*25);//根据勾股定理求出另一条直角边长 var d4:Number=Math.sqrt(d1*d1-25*25);

//计算圆心得角度

var ang1:Number=Math.atan2(mccir.y-circle1.y,mccir.x-circle1.x);//圆形相对于左端角度

var ang2:Number=Math.asin(25/d2);//左边直角三角形的一个锐角度数 var ccir.y-circle2.y,mccir.x-circle2.x);//右边 ang3var ang4:Number=Math.asin(25/d1);//右边

graphics.clear(); :Num

graphics.lineStyle(3,0xffffff*Math.random ()); ber=

graphics.moveTo(circle1.x,circle1.y); Math

if (mccir.y>=100) {

.ata

graphics.lineTo(circle1.x+d3*Math.cos(ang1+ang2),circ

n2(m

le1.y+d3*Math.sin (ang1+ang2));

} else {

graphics.lineTo(mccir.x,mccir.y+25); }

//以左端为圆心以非半径的直角三角形边长为半径的圆的参数方程求出切点坐标 if (mccir.y>=100) {

graphics.moveTo(circle2.x+d4*Math.cos(ang3-ang4),circle2.y+d4*Math.sin (ang3-ang4)); }else{

graphics.moveTo(mccir.x,mccir.y+25); }

graphics.lineTo(circle2.x,circle2.y); }

第三章 实例47 彩色的云雾效果

import flash.display.Bitmap; import flash.display.BitmapData;

var bmd:BitmapData = new BitmapData(800, 600, true, 0x00CCCCCC); var seed:Number = Math.floor(Math.random() * 10000);

var channels:uint = BitmapDataChannel.GREEN | BitmapDataChannel.BLUE| BitmapDataChannel.RED ;

bmd.perlinNoise(200, 200, 6, seed, false, true, channels, false, null); var bm:Bitmap = new Bitmap(bmd); addChild(bm);

bm.x = stage.stageWidth/2 - bm.width/2; bm.y = stage.stageHeight/2 - bm.height/2;

stage.addEventListener(Event.ENTER_FRAME,enterFrameHandler); function enterFrameHandler(e:Event):void{ seed = Math.floor(Math.random() * 999999);

bmd.perlinNoise(200, 200, 6, seed, false, true, channels, false, null); bm.bitmapData = bmd; }

实例48 圆圈遮罩效果

var speedx:Number=Math.random()*20-10; var speedy:Number=Math.random()*20-10;

var masks:Array =new Array();//用来添加每一张遮罩图片 var masksp:Sprite =new Sprite();//用来装所有的这招图片 addChild(masksp);//把容器添加到舞台中 bgimg.mask=masksp;//遮罩容器遮罩背景图片

var maskmc:MovieClip =new Mymask();//实例化一个跟随鼠标的遮罩mc并添加到遮罩容器中

maskmc.width=maskmc.height=50;

addEventListener(Event.ENTER_FRAME ,f);//实现跟随鼠标 function f(e) {maskmc.x=mouseX; maskmc.y=mouseY;

masksp.addChild(maskmc);}

var timer:Timer=new Timer(500,0);//该时间侦听器实现没0.5秒出现一个遮罩图片 timer.addEventListener(TimerEvent.TIMER, timerEvent); timer.start();

function timerEvent(e:TimerEvent):void { var scale:Number=Math.random()*0.8+0.5; var mc:MovieClip=new Mymask();

mc.x=mouseX;//每个实例化出来的图片出现时的坐标都同鼠标坐标 mc.y=mouseY;

masksp.addChild(mc);//添加到遮罩容器中 mc.scaleX=mc.scaleY=scale;

masks.push(mc);//添加到遮罩数组中}

addEventListener(Event.ENTER_FRAME ,ff);

function ff(e) {//实现遮罩数组中的每个图片运动效果，并且逐渐放大并减少透明度

for (var i:int=0; iif (maskmc.alpha<0) {masks.splice(i,1); masksp.removeChild(maskmc);}}

实例49 全脚本旋转的彩色立方体

[SWF(backgroundColor=0x0000ff)]//设置舞台背景颜色为蓝色 //======================自定义函数画矩形

function rectF():Shape {//自定义函数，返回类型为Shape var rect:Shape=new Shape();//声明一个矢量图类实例

rect.graphics.lineStyle(1,0);//设置画线样式（宽为1,颜色为黑色）

rect.graphics.beginGradientFill(GradientType.RADIAL,[0x999999,0x000000],[1,0.4],[0,180]);//设置填充样式（放射状，灰色到白色，不透明到半透明，色块位置为0到180）

rect.graphics.drawRect(-50,-50,100,100);//画矩形（左上角坐标（－50,－50），

宽100,高100

addEventListener(Event.ENTER_FRAME,f);//添加帧频事件侦听，调用函数f function f(e) {//定义函数f

if (Math.random()<0.05) {//如果随机数小于0.05 rect.transform.colorTransform=new

ColorTransform(1,1,1,1,Math.random()*510-255,Math.random()*510-255,Math.random()*510-255,0);//矩形颜色变化（红绿蓝透明通道乘数值为1,红绿蓝通道偏移量为－255－255之间任意数） } }

return rect;//返回 }

//======================调用自定义函数作背景

var sh:Shape=rectF();//声明变量sh，获取对自定义函数的调用 addChildAt(sh,0);//把sh添加到显示列表的最底层 sh.width=550;//宽550 sh.height=400;//高400 sh.x=275;//X坐标275 sh.y=200;//Y坐标200

//======================自定义函数作体面

function rectD():Sprite {//自定义函数，返回类型为Sprite var sp:Sprite=new Sprite();//声明一个容器类实例 for (var i:int=0; i<2; i++) { for (var j:int=0; j<2; j++) {

var mc:Shape=rectF();//声明一个矢量图类实例，获取对自定义函数的调用 sp.addChild(mc);//添加显示列表 mc.x=100*j-50;//X坐标 mc.y=100*i-50;//Y坐标 } }

return sp;//返回 }

//======================画正方体 var rectT:Sprite=new Sprite(); addChild(rectT); rectT.x=275; rectT.y=200;

var arr:Array=[];//声明空数组arr

var arrMat:Array=[];//声明空数组arrMat

function lftF(z:int,rot:uint,ve:Vector3D) {//自定义函数（参数） var mc:Sprite=rectD();//声明一个容器类实例，获取对自定义函数的调用 rectT.addChild(mc);//添加到rectT中

var mat:Matrix3D = new Matrix3D();//声明一个3D矩阵类实例 mat.appendTranslation(0,0,z);//3D空间的坐标

mat.appendRotation(rot,ve);//转过的角度(角度，方向） mc.transform.matrix3D=mat;//把矩阵转换的结果应用到mc

arr.push(mc);//把mc添加到数组arr

arrMat.push(mat);//把矩阵对象mat添加到数组arrMat }

lftF(-100,0,Vector3D.Y_AXIS);//正面 lftF(100,0,Vector3D.Y_AXIS);//对面 lftF(-100,90,Vector3D.Y_AXIS);//左面 lftF(100,90,Vector3D.Y_AXIS);//右面 lftF(-100,90,Vector3D.X_AXIS);//下面 lftF(100,90,Vector3D.X_AXIS);//上面 //======================旋转

addEventListener(Event.ENTER_FRAME,frame);//添加帧频事件侦听，调用函数frame function frame(e) {//定义函数frame for (var j:int=0; jarrMat[j].appendRotation((275-mouseX)/100, Vector3D.Y_AXIS);//后置旋转（角度，方向）

arrMat[j].appendRotation((mouseY-200)/100, Vector3D.X_AXIS); }

arr.sortOn(\"z\把数组arr的元素按Z属性数值倒序排序

for (var i:Number=0; i//======================题目

var txt:TextField=new TextField();//声明一个文本类实例txt addChildAt(txt,numChildren);//把txt添加到显示列表的最底层

txt.defaultTextFormat=new TextFormat(\"隶书\为txt设置文本格式（隶书，30号，深绿色）

txt.text=\"全脚本绚丽色彩立体版\";//文本txt内容 txt.x=20;//文本txt的X坐标获取20 txt.y=20;//文本txt的Y坐标获取20

txt.filters=[new DropShadowFilter(5,45,0xcc3366)];//为文本添加投影滤镜（距离5,方向45度，颜色）

txt.autoSize=TextFieldAutoSize.LEFT;//自动调整大小并左对齐 //setChildIndex(qm_mc,numChildren-1);//设置影片剪辑为最高层

//====================以下是上面签名（qm_mc)元件as。即：插入新建元件qm_mc，拖到场景中给实例名 qm_mc

//var sp:Sprite=new Sprite();//声明一个容器类实例sp //addChild(sp);//把sp添加显示列表

//var arr:Array=[];//声明一个空数组arr

//var str:String=\"春雨习作\";//声明一个字符串型变量str

//for (var i:int=0; i<4; i++) {//创建一个for循环，循环4次

// var mc:MovieClip=new MovieClip();//声明一个影片剪辑类实例mc // sp.addChild(mc);//把mc添加到sp中

// mc.filters=[new DropShadowFilter(4,45)];//对mc应用投影滤镜（4像素，45度） // var txt:TextField=new TextField();//声明一个文本类实例txt

// mc.addChild(txt);//把txt添加显示列表

// txt.defaultTextFormat=new TextFormat(\"华文行楷\为txt设置文本格式（华文行楷，字号50,红色）

// txt.text=str.substr(i,1);//文本的内容获取字符串str从第i个开始后的1个字符

// mc.x=40*Math.cos(i*Math.PI/2);//mc的X坐标

// mc.z=40*Math.sin(i*Math.PI/2);//mc的Z坐标,使这四个字分布在Ｘ轴与Ｚ轴所在的平面以（０,０）点为圆心，半径为５０的圆上 // arr.push(mc);//把mc添加到数组arr中

// mc.addEventListener(Event.ENTER_FRAME,f);//为mc添加帧频事件侦听，调用函数f //}

//function f(e) {//定义事件函数f

// for (var i:int=0; i // arr[i].transform.matrix3D.appendRotation(1,Vector3D.Y_AXIS);//设置字的后置旋转（速度1，围绕父级容器Y轴）

arr[i].transform.matrix3D.prependRotation(-1,Vector3D.Y_AXIS);//设置 字的前置旋转（速度-1，围绕自己的Y轴） // }

// arr.sortOn(\"z\数组arr中元素根据Z坐标按降序排列

// for (var n=0; n // sp.setChildIndex(arr[n],n);//在容器sp中设置子对象arr[n]的层深度为n // } //}

实例50 3D爆炸的小球

import flash.display.MovieClip; import flash.utils.Timer; import flash.media.Sound;

[SWF(backgroundColor = 0x0)]//设置背景

//var ExplosionSound:Sound=new YY();//声明一个声音类的变量并把库里声音实例化出来在赋值给变量

function Explosion() {//自定义函数

var time:Timer = new Timer(10,1);//声明一个Timer事件，每0.01秒执行1次 time.start();//如果计时器尚未运行，则启动计时器 time.addEventListener(TimerEvent.TIMER,ontime); function ontime(e) {//给计时器加侦听事件

var ball0:MovieClip=new MovieClip();//声明一个变量球类形影片剪辑 addChild(ball0);//让球显示在舞台上 ball0.x = 275; ball0.y = 200;

ball0.graphics.beginGradientFill(\"radial\],[1,1],[0,10]);

ball0.graphics.drawCircle(0,0,3); ball0.graphics.endFill();

ball0.addEventListener(Event.ENTER_FRAME,ballscale);//给球加侦频事件 var v:Number=0.3//速度为0.3

function ballscale(e) {//自定义函数

ball0.scaleX = ball0.scaleY += v;//球侦频的运动大小缩放速度比例为速度加0.3倍 if (ball0.scaleY>10||ball0.scaleX > 10) {//在侦频事件里如果球运动纵方向大于10或球运动的横坐标的方向大于10

ball0.removeEventListener(Event.ENTER_FRAME,ballscale);//横纵坐标缩放是原来10倍大于10这个圆就移除侦频事件

removeChild(ball0);//;//实例的子列表中删除指定的实例爆 炸时称除这个圆 }// }// }//

time.addEventListener(TimerEvent.TIMER_COMPLETE,ballscaleover); function ballscaleover(e) {//计时器完成事件 t.start();//则启动计时器 }

var t:Timer = new Timer(1000);// 每1000毫秒执行一次声明一个Timer事件 t.addEventListener(TimerEvent.TIMER,onT); function onT(e) { //

// ExplosionSound.play(100,1)//在这个时间事件里让声音0.1秒执行一次 for (var i:int=0; i<20; i++) {// for (var j:int=0; j<20; j++) {

var ball:MovieClip=new MovieClip(); addChild(ball);

ball.graphics.beginGradientFill(\"radial\,[1,1],[0,20]);

ball.graphics.drawCircle(0,0,5); ball.graphics.endFill(); ball.x = 275; ball.y = 200;

ball.z=(1000-50*(j*1.5));//

ball.vx = Math.random() * 10 - 5;//在-5到5之间 ball.vy=Math.random()*10-5;;

ball.vz=Math.random()*30-15;;;//在-15到15之间 ball.addEventListener(Event.ENTER_FRAME,ballmove); }//给球加侦频事件 }

function ballmove(e) {

var ball = e.target;//让这个球 ball.x += ball.vx;//横坐标为球 ball.y += ball.vy;// ball.z += ball.vz;//

if (ball.x > 700 || ball.x < -100 || ball.y > 600 || ball.y < -100 || ball.z < -200 || ball.z > 800) {

ball.removeEventListener(Event.ENTER_FRAME,ballmove); removeChild(ball);//实例的子列表中删除指定的实例 t.stop();

} } } }

Explosion()//调用上面的函数

stage.addEventListener(MouseEvent.CLICK,dj) function dj(e){ Explosion() }

实例51 音波条制作

[SWF(backgroundColor=0x000000)]//设置背景的颜色，值为 0x000000（黑色）。 btn.stop();

const W:Number=stage.stageWidth;

const H:Number=stage.stageHeight;//申明2个常量，设置 var sound:Sound=new Yy();//把音乐链接

var soundChannel:SoundChannel = new SoundChannel();//注册声音通道

var bytes:ByteArray=new ByteArray();//ByteArray 类提供用于优化读取、写入以及处理二进制数据的方法和属性

var bool:Boolean=true;//申明布尔变量 var sp:Sprite =new Sprite(); btn.buttonMode=true;

btn.addEventListener(MouseEvent.CLICK,ck);//给按钮注册一个鼠标事件侦听器 function ck(evt:MouseEvent):void {

if (bool==true) {//如果布尔值为真，将执行下面任务 btn.gotoAndStop(2);//按钮跳转到第二帧停止 soundChannel=sound.play();//音乐开始播放

soundChannel.addEventListener(Event.SOUND_COMPLETE,Complete);//给音乐播放完了注册一个侦听

addEventListener(Event.ENTER_FRAME,frame);// } else {//否则，

btn.gotoAndStop(1);//按钮跳转到第一帧停止 soundChannel.stop();//音乐停止 }

bool=! bool; }

function Complete(evt:Event):void {

removeEventListener(Event.ENTER_FRAME,frame); btn.gotoAndStop(1); bool=true; }

function frame(evt:Event):void {

SoundMixer.computeSpectrum(bytes,true,0);//获取当前声音波形的快照 XG();//调用效果 }

//音波条效果

function Rect(w:Number,h:Number,color:uint):Shape {//自定义画矩形的函数

var rect:Shape = addChild(new Shape()) as Shape;//画矩形

var fliters:Array =[new GlowFilter(),new DropShadowFilter(5, 45, 0, 0.5, 3, 3, 1, 1, true,false)]; rect.filters =fliters///**/

//rect.filters=[new GlowFilter()];

//rect.filters=[new DropShadowFilter(5, 45, 0, 0.5, 3, 3, 1, 1, true,false)] ;//注意滤镜的添加如果是按照先后顺序那么后面的滤镜方式会覆盖上面的，例如上面屏蔽的写法而只执行最后一种效果，如果想同时执行几种 //滤镜效果则应该像这种形式：先把几种滤镜压缩到一个数组中，然后再把滤镜数组添加给元件

var matrix:Matrix =new Matrix();

matrix.createGradientBox(8,20,90,0,0);

rect.graphics.beginGradientFill(GradientType.LINEAR,[color,0xff0000],[1,1],[0,255],matrix);//定义矩形的颜色

//=========效果一矩形条在对称轴上下两侧跳动

//rect.graphics.drawRect(-w/2,-h/2,w,h);//定义矩形的注册点位置及宽和高 //=========效果二矩形条在直线上侧跳动 rect.graphics.drawRect(-w,-h,w,h) rect.graphics.endFill();//对矩形进行填充 return rect;//返回 }

var rectNum:uint=30;//矩形的数量 var rectW:Number=8;//矩形的宽 var rectH:Number=20;//矩形的高

var rectSpr:Sprite = addChild(new Sprite()) as Sprite;//定义一个放矩形的容器

rectSpr.x=W/2,rectSpr.y=H/2;//容器的位置

for (var i:uint=0; ivar rect:Shape=Rect(rectW,rectH,0xffffff*Math.random());//创建新的 Shape 对象

// var rect:MovieClip = new Mc(); //rect.height=20;

rectSpr.addChild(rect);//将矩形添加到显示对象容器 //======效果一矩形条从中间向左右两边展开 //if (i// rect.x=(i-rectNum/2)*(rectW+5); // }

//=============效果二矩形条都在直线右侧侧跳动 rect.x= -(rectNum/2-i)*(rectW+5); }

function XG() {//自定义 XG 函数 for (var i:uint=0; ifor (var j:uint=0; j<8; j++) { n+=bytes.readFloat();

}

rectSpr.getChildAt(i).scaleY=0.3+n; } }

实例52 贝塞尔曲线

var tim:Timer=new Timer(800,0);//每800毫秒 无限循环 tim.start();//记时器运行

tim.addEventListener(TimerEvent.TIMER,timer);//添加记时事件 var sprb:Sprite=new Sprite();//用来装背景的容器 addChildAt(sprb,0);//放到0层 function timer(e:TimerEvent) { aa();

sprb.numChildren>1?sprb.removeChildAt(0):0;

spq.filters=[new GlowFilter(0xffff00*Math.random(),0.8,4,4,10,10)];//贝塞尔曲线的发光滤镜，filters一个数组，其中包含要在某个特定关键帧应用到目标对象的所有滤镜对象。

//参数颜色 透明度 水平模糊量 垂直模糊量 印记或跨页的强度 应用滤镜的次数 }

function aa() {

var bmd:BitmapData=new BitmapData(550,400);//背景位图数据 var bmp:Bitmap=new Bitmap(bmd);//显示背景数据容器 sprb.addChild(bmp);//用sprb容器加背景

bmd.perlinNoise(120,80,2,5*Math.random(),false,false,1+7*Math.random());// //要在 x 方向上使用的频率 要在 y 方向上使用的频率 要组合以创建此杂点的 octave 函数或各个杂点函数的数目 要使用的随机种子数。一个布尔 值用于作为位图填充进行平铺。 一个布尔值。 如果该值为 true，则该方法将生成碎片杂点；否则，它将生成湍流 一个数字，可以是四个颜色通道值 }

aa();//避免刚开始运行时的空白背景画面 //=========边框 var

brr:Array=[[550,0],[550-20,20],[20,20],[0,0],[20,20],[20,400-20],[0,400],[0,0]];

for (var n:uint=0; n<2; n++) { var sprk:Sprite=new Sprite(); addChildAt(sprk,1);

sprk.graphics.moveTo(0,0)

for (var j:uint=0; jvar myMatrix:Matrix = new Matrix();

j<3?myMatrix.createGradientBox(550,20,Math.PI/2):myMatrix.createGradientBox(20,400);//横向边框的填充框旋转90度，纵向不转 with(shp.graphics){

beginGradientFill(\"linear\],myMatrix);

lineTo(brr[j][0],brr[j][1]);

lineTo(brr[(j+1)%brr.length][0],brr[(j+1)%brr.length][1]); }

n==1?[sprk.rotation=180,sprk.x=550,sprk.y=400]:0; } }

//=====贝塞尔曲线 var i:Number;

var arr:Array=new Array(); var ang:Number=0;

var spq:Sprite=new Sprite(); addChild(spq);

addEventListener(Event.ENTER_FRAME,f); function f(e:Event):void { arr=[]; ang+=0.004;

ang>=Math.PI*2?ang=0:0 for (i=0; i<20; i++) {

var a:Number=275+Math.cos(ang*i)*150;//圆上的锚点和控制点 var b:Number=200+Math.sin(ang*i)*150; arr.push([a,b]); }

spq.graphics.clear();

spq.graphics.lineStyle(2,0xffffff,0.8);

spq.graphics.moveTo(275,200);//l两条贝塞尔曲线花瓣的起终点 for (i=1; i<19; i++) {

spq.graphics.curveTo(arr[i-1][0],arr[i-1][1],arr[i][0],arr[i][1]); spq.graphics.curveTo(arr[i+1][0],arr[i+1][1],275,200); } }

实例53 电子字母牌

[SWF(width=\"550\ var bid:BitmapData; function init() {

var sp:Sprite =new Sprite();

var txt:TextField =new TextField(); txt.autoSize=TextFieldAutoSize.LEFT; txt.background=true; txt.backgroundColor=0;

txt.text=\"河南滑县崔仙霞qq825010428\"; var format:TextFormat=new TextFormat(); format.color=0xff0000; format.size=15;

format.letterSpacing=10;//一个整数，表示在所有字符间统一分配的空格量。 该值指定在每个字符之后添加到进距的像素数。 默认值为 null，这意味着使用的字母间距为 0 像素

txt.setTextFormat(format);

bid=new BitmapData(txt.width,txt.height); bid.draw(txt);//用位图拍照文本

var map:Bitmap =new Bitmap(bid) addChild(map)

for (var y:int=0; yvar color:uint=bid.getPixel(x,y);//获取拍照位图的每一个点像素的值 //if (color>0) {

// bid.setPixel(x,y,0xff0000); // } else {

// bid.setPixel(x,y,0x0000000); // } } }

addEventListener(Event.ENTER_FRAME ,frame); }

//绘制点函数 function

drawDot(x:Number,y:Number,size:Number,colorLight:uint,colorDark:uint):void {

var colors:Array=[colorLight,colorDark]; var alphas:Array=[1,1];

var ratios:Array=[0,255]; var matrix:Matrix=new Matrix();

matrix.createGradientBox(size*2,size*2,0,x-size,y-size); graphics.beginGradientFill(\"radial\ graphics.drawCircle(x,y,size); }

var speed:int=-100 function frame(e) { speed+=2;

if (speed>bid.width) { speed=-100; }

graphics.clear();

for (var y:int=0; y<18; y++) {

for (var x:int=0; x<100; x++) { var pixel=bid.getPixel(x+speed,y);//

//此公式的含义是从左往右依次获取点的像素的，设从o的位置开始宽为speed的点位置那么

//对应小球的位置应该是从右到左宽慰speed的位置而坐标应该是从左往右计算的所以是x=100-speed//

//所以当反过来当小球的位置坐标为x的时候，speed=100-x但是这时候出现的左右对称现象所以再取相反数x-100

//让后让speed逐渐增加即可这时初始值为-100的原因 if (x>bid.width) { pixel=0; } else {

bid.getPixel(x+speed,y); }

if (pixel!=0) {

drawDot(30+x*5,40+y*5,2.5,0xff0000,0xffff00); } else {

drawDot(30+x*5,40+y*5,2.5,0xff00ff,0x800000); } } } }

init();

var txt:TextField=new TextField(); txt.x=60,txt.y=150;

txt.defaultTextFormat=new TextFormat(\"长城粗魏碑体xt.text=\"电子活动字幕 制作--得失随缘\"; txt.filters=[new

BevelFilter(1,45,0xFFFFFF,1,0x000000,1,1,1,1,1,\"inner\ txt.autoSize=TextFieldAutoSize.LEFT; txt.selectable=false; addChild(txt);

实例54 飞舞的彩球

[SWF(backgroundColor=0x000000)] const W:Number=stage.stageWidth; const H:Number=stage.stageHeight; var num:uint=20;

function Bubble(color1:uint,color2:uint,r:Number):Sprite { var bubble:Sprite = addChild(new Sprite()) as Sprite;

bubble.graphics.beginGradientFill(\"radial\55]);

bubble.graphics.drawCircle(0,0,r); bubble.graphics.endFill();

var bubble1:Sprite = bubble.addChild(new Sprite()) as Sprite; bubble1.graphics.beginFill(0xffffff,0.85); bubble1.graphics.drawCircle(0,0,20); bubble1.scaleX=0.45;

bubble1.x=- r*0.58,bubble1.y=- r*0.58; bubble1.rotation=45;

bubble1.graphics.endFill(); return bubble; }

var bubbleSpr:Sprite = addChild(new Sprite()) as Sprite; var bubbleMask:Sprite = addChild(new Sprite()) as Sprite; bubbleMask.graphics.beginFill(0);

bubbleMask.graphics.drawRect(0,0,W,H); bubbleMask.graphics.endFill(); bubbleSpr.mask=bubbleMask;

function BubbleMove(yy:Number) { var

bubble:Sprite=Bubble(0xffffff*Math.random(),0xffffff*Math.random(),125);

bubbleSpr.addChild(bubble);

var tx:Number=bubble.x=W*Math.random(); bubble.y=yy;

bubble.scaleX=bubble.scaleY=0.1+0.2*Math.random(); var vy:Number=1+3*Math.random(); var angle:Number=0.01;

var ang:Number=0.02+0.03*Math.random(); var d:Number=10+15*Math.random();

bubble.addEventListener(Event.ENTER_FRAME,bubbleFrame); function bubbleFrame(evt:Event):void { angle+=ang;

bubble.x=tx+d*Math.sin(angle); bubble.y-=vy;

if (bubble.y<=0-bubble.height/2) {

bubble.removeEventListener(Event.ENTER_FRAME,bubbleFrame); bubbleSpr.removeChild(bubble); BubbleMove(H+bubble.height/2); } } }

for (var i:uint=0; i实例55 模拟卷轴动画

var sp:Sprite =new Sprite(); addChild(sp); sp.x=275; sp.y=50;

var zhousp:Sprite =new Sprite(); sp.addChildAt(zhousp,0);

function quxianf():MovieClip { var quxian:MovieClip =new MovieClip(); quxian.graphics.lineStyle(2,0xffff00); quxian.graphics.moveTo(-250,0); quxian.graphics.lineTo(-200,0);

quxian.graphics.lineStyle(5,0xff0000); quxian.graphics.lineTo(-200,5); quxian.graphics.lineTo(200,5); quxian.graphics.lineTo(200,0);

quxian.graphics.lineStyle(2,0xffff00); quxian.graphics.lineTo(250,0); return quxian; }

//sp.addChild(quxian);

var arr:Array =new Array();

for (var i:int =0; i<36; i++) { var mc:MovieClip=quxianf(); arr.push(mc);

zhousp.addChild(mc); mc.x=0; mc.y=0; mc.z=10;

mc.transform.matrix3D.appendRotation(i*10,Vector3D.X_AXIS); }

function zhouf(e) { arr.sortOn(\"z\

for (i=0; izhousp.rotationX+=5; }

var pic:BitmapData=new Pic(0,0); for (var k:int=0; k<60; k++) {

var xiaotu:MovieClip =new MovieClip(); sp.addChildAt(xiaotu,k+1);

var matrix:Matrix =new Matrix();

matrix.createBox(1,1,0,-200,-10*k);

xiaotu.graphics.beginBitmapFill(pic,matrix,true,false); xiaotu.graphics.drawRect(-200,-5,400,10); xiaotu.x=0;

xiaotu.y=k*10+15; xiaotu.z=10; }

stage.addEventListener(MouseEvent.MOUSE_DOWN ,df); function df(e) {

zhousp.addEventListener(Event.ENTER_FRAME ,zhouf); addEventListener(Event.ENTER_FRAME ,xiaotuf); }

function xiaotuf(e) { for (k=0; k<60; k++) {

var mc:MovieClip=sp.getChildAt(k+1) as MovieClip; mc.y-=5;

if (mc.y<-15) { mc.y=-15 } }

if (sp.getChildAt(59).y==0){

removeEventListener(Event.ENTER_FRAME ,xiaotuf);

zhousp.removeEventListener(Event.ENTER_FRAME ,zhouf); stage.removeEventListener(MouseEvent.MOUSE_DOWN ,df);} }

实例62 可以改变边数的贴图正棱柱

var m:int=0;

setChildIndex(txt,0);//把场景中的输入文本框设置为0层 setChildIndex(qianming,1);

txt.addEventListener(Event.CHANGE ,changf);

addEventListener(Event.ENTER_FRAME ,changf);//初始值为六棱柱默认进入时间轴即执行一次六棱柱 function changf(e) {

//============首先删除场景中默认的六棱柱函数否则然后 removeEventListener(Event.ENTER_FRAME ,changf);

//============当改变数字时候应该先删除原来的棱柱 while (numChildren!=2) {

//当场景中的元件数目不等于一时就一直删除一层的元件 //这样就只剩下0层的文本框了了 removeChildAt(2); }

//==========初始化棱柱需要的数据 var bmp0:BitmapData=new Img(0,0);

var num:uint=uint(txt.text);//初始值为六棱柱 var w:Number=bmp0.width/num; var h:Number=bmp0.height-100;

//四棱柱的底面边长要用整张图包围棱柱所以用图宽度除以变数 var ang:Number=360/num/2;//正多边形的圆心角的一半 //trace(ang)

var r:Number=w/2/Math.tan(ang*Math.PI/180);//正多边形的内切圆半径 //切割位图得到四张图片

var arr:Array=[];//存放切割的小位图的数组 var sp:Sprite =new Sprite();//存放小位图的容器

addChildAt(sp,2);//把棱柱容器添加到一层为了将来的删除2层 sp.x=275;//让容器中的图片居中对齐 sp.y=200;

//=============切割小位图并存放到容器中 for (var i:int=0; ivar mc:MovieClip =new MovieClip(); sp.addChild(mc);

var bmp:BitmapData=new BitmapData(w,h); var rect:Rectangle=new Rectangle(w*i,0,w,h); var p:Point=new Point(0,0); bmp.copyPixels(bmp0,rect,p);

var bmd:Bitmap=new Bitmap(bmp); mc.addChild(bmd); arr.push(mc); mc.x=- w/2; mc.y=- h/2; mc.z=r;

mc.transform.matrix3D.appendRotation(i*ang*2,Vector3D.Y_AXIS); mc.addEventListener(Event.ENTER_FRAME ,f); }

//=============给每张小位图添加旋转帧频函数

function f(e) {

for (var j:int=0; jmcc.transform.matrix3D.appendRotation(-(mouseX-275)/100,Vector3D.Y_AXIS); mcc.transform.matrix3D.appendRotation((mouseY-200)/100,Vector3D.X_AXIS); }

arr.sortOn(\"z\按照z坐标重新倒叙排列

for (var n:int =0; n实例56 流动的图片

var pic:BitmapData=new Pic(0,0);//导入库中的位图 var sp:Sprite =new Sprite(); sp.x=275;

arr.push(xiaotu); sp.y=20;

sp.addChildAt(xiaotu,k); var arr:Array=[];

var matrix:Matrix =new Matrix(); addChild(sp);

matrix.createBox(1,1,0,-200,var zhenfu:Number=30;

-2*k);//xy方向的缩放值分别是var bochang:Number=50;

1，即保持 for (var k:int=0; k<300; k++) {

var xiaotu:MovieClip =new MovieClip(); 不变，旋转角度为0

//因为图片宽400，因此每次拍照时要把被拍照对象向平移 //200个像素，又因为小图片的宽是2，因此需要向上平移k个2 xiaotu.graphics.beginBitmapFill(pic,matrix,true,false); xiaotu.graphics.drawRect(-200,-5,400,2); xiaotu.x=0; xiaotu.y=k*2;

xiaotu.z=zhenfu*Math.cos(k*Math.PI/bochang); }

var i:int=0;

var t:Timer=new Timer(1); t.start();

t.addEventListener(TimerEvent.TIMER ,f); function f(e) {

arr[0].z=zhenfu*Math.cos(i*Math.PI/bochang);//第一个小图片做余弦曲线摆动 for (k=1; karr[k].z+=(arr[k-1].z-arr[k].z)/2;//其余图片做鼠标跟随z坐标的缓动效果，类似于鼠标跟随只不过不是z坐标的跟随 } i+=1; }

实例57 全脚本美丽线条

[SWF(backgroundColor=0)]

const lineNum:uint=20;//定义线的条总数

const spNum:uint=2;//容器总数

const zhS:Number=1;//容器转动速度

var ky:Number=-50;///画曲线的初始控制点纵坐标是-50 var a:Number=0.1;//控制点纵坐标上下运动的速度 function xianF():Shape {//画线函数 var sh:Shape=new Shape();

addEventListener(Event.ENTER_FRAME,f); function f(e) {

ky+=a;//控制点的纵坐标变化 sh.graphics.clear();

sh.graphics.lineStyle(1,0xffffff*Math.random()); sh.graphics.moveTo(0,0);

sh.graphics.curveTo(50,ky,150,0); if (ky>=50||ky<=-50) {//限制控制点的纵坐标为-50到50之间变化 a=- a; } } return sh;

}

for (var i:int=0; ifor (var j:int=0; jxian.x=25*Math.cos(j*(360/lineNum)*Math.PI/180);

xian.y=25*Math.sin(j*(360/lineNum)*Math.PI/180);

xian.rotation=j*(360/lineNum)+120; // } }

var sp0=getChildAt(0);//按照层深获取两个相同的容器

var sp1=getChildAt(1);

sp1.scaleX=-1;//让其中一个反向翻转 addEventListener(Event.ENTER_FRAME,ff);

function ff(e) {

sp0.rotation+=zhS;//一个正向旋转

sp1.rotation-=zhS;//另一个反向旋转 }

//===============签名

var txt2:TextField=new TextField();//

声明一个文本类实例txt addChildAt(txt2,numChildren-1);//把txt添加到显示列表的最顶层

txt2.defaultTextFormat=new TextFormat(\"隶书\为txt设置文本格式（隶书，30号，深绿色）

txt2.text=\"全脚本美丽动线\";//文本txt内容 txt2.x=20;//文本txt的X坐标获取20 txt2.y=20;//文本txt的Y坐标获取20 txt2.autoSize=TextFieldAutoSize.LEFT;

txt2.filters=[new DropShadowFilter(5,45,0xcc3366)];//为文本添加投影滤镜（距离5,方向45度，颜色）

var txt1:TextField=new TextField();//声明一个文本类实例txt addChildAt(txt1,numChildren);//把txt添加到显示列表的最顶层

txt1.defaultTextFormat=new TextFormat(\"华文行楷\为txt设置文本格式（隶书，30号，深绿色）

txt1.text=\"三叶草平安qq825010428\";//文本txt内容 txt1.x=340;//文本txt的X坐标获取340 txt1.y=360;//文本txt的Y坐标获取360 txt1.autoSize=TextFieldAutoSize.LEFT;

txt1.filters=[new DropShadowFilter(5,-45,0xcc3366)];//为文本添加投影滤镜（距离5,方向45度，颜色）

实例58 简单的倒计时

fen_txt.backgroundColor=0xff0000;//两个输入文本元件 miao_txt.backgroundColor=0xffff00;

var miao:Number;//注意先声明变量，而不复制因为下面两个函数中都要用到这个变量因此设为总变量 var fen:Number;

miao_txt.maxChars=fen_txt.maxChars=2;//限制输入最大字符为2

miao_txt.restrict=\"0-9\";//限制只能输入数字字符防止输入汉字或其他字母 btn.addEventListener(MouseEvent.CLICK ,f); var timer:Timer=new Timer(100); function f(e) {

miao_txt.mouseEnabled=false;//倒计时开始后文字不能再改变因此设置为不再可选

fen_txt.mouseEnabled=false; miao=int(miao_txt.text); fen=int(fen_txt.text); timer.start();

timer.addEventListener(TimerEvent.TIMER ,jishi); }

function jishi(e) {

btn.removeEventListener(MouseEvent.CLICK ,f); miao>0?[miao--,miao_txt.text=miao+\"\"]:0;

if (miao==0&&fen>0) {//如果分大于0秒等于0时则把一分化为六十秒并且分减去一 miao=60; fen-=1;

fen_txt.text=fen+\"\"; }

if (fen==0&&miao==0) {//当分为0且秒也为0的时候则删除时间侦听器，按钮重新添加点击事件

timer.removeEventListener(TimerEvent.TIMER ,jishi); btn.addEventListener(MouseEvent.CLICK ,f);

miao_txt.mouseEnabled=true;//倒计时开始后文字不能再改变因此设置为不再可选 fen_txt.mouseEnabled=true; } }

实例59 自定义右键菜单的设置截图拍照

var caidan:ContextMenu =new ContextMenu(); caidan.hideBuiltInItems();

var jietu:ContextMenuItem=new ContextMenuItem(\"截图\");//定义一个右键菜单的变量

caidan.customItems.push(jietu); var pic:BitmapData=new Pic(0,0); var pit:Bitmap=new Bitmap(pic); var mc:MovieClip =new MovieClip(); mc.addChild(pit); addChild(mc);

mc.contextMenu=caidan;var bit:BitmapData=new BitmapData(100,100); var bmp:Bitmap=new Bitmap(bit); var xx:Number; var yy:Number;

stage.addEventListener(MouseEvent.CLICK ,f); function f(e) {

jietu.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT ,jietuf} function jietuf(e) { xx=mouseX; yy=mouseY; bmp.x=mouseX; bmp.y=mouseY;

var matrix:Matrix =new Matrix();

matrix.createBox(1,1,0,-xx+50,-yy+50);//参数分别是xy方向上的缩放值，旋转角度，xy方向上的偏移值，

//因为下面的矩形是从注册点0,0位置开始的，因此要把被拍照的位置移动到左上角，先记录鼠标现在的位置即

//是要被拍照的位置，因此把此位置向上向左平移，再加上图片高宽的一半即可 var rect:Rectangle=new Rectangle(0,0,100,100);//限制了被拍照对象的右上角坐标，和高宽

var color:ColorTransform =new ColorTransform(); var point:Point =new Point();

bit.draw(pic,matrix,color,null,rect,false); addChild(bmp); }

实例60 地球贴图

var num:int=20,i:int,j:int; var

x0:Array=[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]]; var

y0:Array=[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]]; var

z0:Array=[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]];

var p:Number=Math.PI,f:Number=700; var sp:Sprite=new Sprite(); sp.x=275,sp.y=200; var bb:Boolean=false;

var oldx:Number=mouseX,oldy:Number=mouseY; addChild(sp);

for (i=0; ix0[i][j]=160*Math.sin(j*p/num)*Math.cos(i*2*p/num); y0[i][j]=160*Math.cos(j*p/num);

z0[i][j]=160*Math.sin(j*p/num)*Math.sin(i*2*p/num); } }

var map:Tuu=new Tuu(0,0);

var bmp:BitmapData=new BitmapData(map.width,map.height,false); bmp.draw(map);

var anglex:Number=0,angley:Number=0.05;

stage.addEventListener(MouseEvent.MOUSE_DOWN,down); stage.addEventListener(MouseEvent.MOUSE_UP,up); function down(e) { bb=true; }

function up(e) { bb=false; }

addEventListener(Event.ENTER_FRAME,fff); function fff(e:Event) { if(bb) {

anglex=(oldy-mouseY)/600,angley=(mouseX-oldx)/600;

}

for (i=0; ivar tmy:Number=y0[i][j]*Math.cos(anglex)+z0[i][j]*Math.sin(anglex); var tmz:Number=z0[i][j]*Math.cos(anglex)-y0[i][j]*Math.sin(anglex); var tmx:Number=x0[i][j]*Math.cos(angley)-tmz*Math.sin(angley); var tmzz:Number=tmz*Math.cos(angley)+x0[i][j]*Math.sin(angley); x0[i][j]=tmx; y0[i][j]=tmy; z0[i][j]=tmzz; } }

sp.graphics.clear(); for (i=0; ivar x1:Number=x0[i][j]*f/(f+z0[i][j]),y1:Number=y0[i][j]*f/(f+z0[i][j]); var

x2:Number=x0[i][j+1]*f/(f+z0[i][j+1]),y2:Number=y0[i][j+1]*f/(f+z0[i][j+1]); var

x3:Number=x0[i+1][j+1]*f/(f+z0[i+1][j+1]),y3:Number=y0[i+1][j+1]*f/(f+z0[i+1][j+1]); var

x4:Number=x0[i+1][j]*f/(f+z0[i+1][j]),y4:Number=y0[i+1][j]*f/(f+z0[i+1][j]);

var vArr:Vector.=Vector.([x1,y1,x2,y2,x3,y3,x4,y4]); var ind:Vector.=Vector.([0,1,3,1,2,3]); var

uArr:Vector.=Vector.([i/num,(num-j)/num,i/num,(num-j-1)/num,(i+1)/num,(num-j-1)/num,(i+1)/num,(num-j)/num]); sp.graphics.beginBitmapFill(bmp);

sp.graphics.drawTriangles(vArr,ind,uArr,TriangleCulling.NEGATIVE); sp.graphics.endFill(); } } }

实例61 疏密波效果

var n:int=70;//线段的条数

var a:Number=10;//正弦波的振幅 var i:Number =0;//控制时间的增加 var arr:Array=[];

for (var k:int=0; kvar segment:MovieClip =new MovieClip();

addChild(segment); arr.push(segment);

segment.graphics.lineStyle(1,0xffffff*Math.random()); segment.graphics.moveTo(0,0); segment.graphics.lineTo(0,200); segment.x=20+k*10; segment.y=100;

segment.filters =[new GlowFilter(),new BevelFilter()]; segment.alpha =0.8

segment.addEventListener(Event.ENTER_FRAME ,f); function f(e) {

var mc:MovieClip=e.target; //trace(getChildIndex(mc));

mc.x=getChildIndex(mc)*10+100*Math.sin ((i+getChildIndex(mc))*Math.PI /180) ;

i+=0.1;}}

实例62 可以改变边数的贴图正棱柱

var m:int=0;

setChildIndex(txt,0);//把场景中的输入文本框设置为0层 setChildIndex(qianming,1);

txt.addEventListener(Event.CHANGE ,changf);

addEventListener(Event.ENTER_FRAME ,changf);//初始值为六棱柱默认进入时间轴即执行一次六棱柱 function changf(e) {

//============首先删除场景中默认的六棱柱函数否则然后 removeEventListener(Event.ENTER_FRAME ,changf);

//============当改变数字时候应该先删除原来的棱柱 while (numChildren!=2) {

//当场景中的元件数目不等于一时就一直删除一层的元件 //这样就只剩下0层的文本框了了 removeChildAt(2); }

//==========初始化棱柱需要的数据 var bmp0:BitmapData=new Img(0,0);

var num:uint=uint(txt.text);//初始值为六棱柱 var w:Number=bmp0.width/num; var h:Number=bmp0.height-100;

//四棱柱的底面边长要用整张图包围棱柱所以用图宽度除以变数 var ang:Number=360/num/2;//正多边形的圆心角的一半 //trace(ang)

var r:Number=w/2/Math.tan(ang*Math.PI/180);//正多边形的内切圆半径 //切割位图得到四张图片

var arr:Array=[];//存放切割的小位图的数组 var sp:Sprite =new Sprite();//存放小位图的容器

addChildAt(sp,2);//把棱柱容器添加到一层为了将来的删除2层 sp.x=275;//让容器中的图片居中对齐 sp.y=200;

//=============切割小位图并存放到容器中 for (var i:int=0; ivar mc:MovieClip =new MovieClip(); sp.addChild(mc);

var bmp:BitmapData=new BitmapData(w,h);

var rect:Rectangle=new Rectangle(w*i,0,w,h); var p:Point=new Point(0,0); bmp.copyPixels(bmp0,rect,p);

var bmd:Bitmap=new Bitmap(bmp); mc.addChild(bmd); arr.push(mc); mc.x=- w/2; mc.y=- h/2; mc.z=r;

mc.transform.matrix3D.appendRotation(i*ang*2,Vector3D.Y_AXIS); mc.addEventListener(Event.ENTER_FRAME ,f); }

//=============给每张小位图添加旋转帧频函数 function f(e) {

for (var j:int=0; jmcc.transform.matrix3D.appendRotation(-(mouseX-275)/100,Vector3D.Y_AXIS);

mcc.transform.matrix3D.appendRotation((mouseY-200)/100,Vector3D.X_AXIS); }

arr.sortOn(\"z\按照z坐标重新倒叙排列

for (var n:int =0; n实例63 3d彩色球

var sp:Sprite =new Sprite(); var arr:Array=[];

var map:BitmapData=new BitmapData(550,400,false,0xff000000); var bit:Bitmap=new Bitmap(map); addChild(bit);

var con:Sprite =new Sprite(); var n=20;//每圈共有几个小球 var m=20;//一共圈数

con.addChild(sp);//因为sp是放在场景的中心，sp的（0,0）位置在球体的中心 trace(con.x) trace(con.y)

//如果直接map拍照sp，map的0，0位置在左上角，所以就只能从sp的中心向右下角部分拍照出来四分之一

//所以先把sp添加到一个更大的容器中这样con默认添加0.0的左上角位置，而sp则在con的中心，

//再用map位图拍照这个大的容器即可拍到全部：从左上角开始拍照 //addChild(con); sp.x=275; sp.y=200;

for (var i:int =0; ivar tran:ColorTransform =new ColorTransform(); tran.color=0xffffff*Math.random(); mc.transform.colorTransform=tran; mc.scaleX=mc.scaleY=0.1;

var ang=2*Math.PI/n;//每个小球间隔的角度

mc.x=150*Math.cos(ang*j);//大球的半径为150因此用圆极坐标计算每个小球的坐标 mc.y=150*Math.sin(ang*j); mc.z=0;

mc.transform.matrix3D.appendRotation(180/m*i,Vector3D.Y_AXIS);

//绕轴公转因为本身是20个圆所以绕轴总共旋转180度即可以得到一个球体，相当于一个半圆旋转360度

//小球在绕旋转轴y轴公转的同时也让自身绕y轴向相反的方向自传同样的角度这样可以达到小球的始终面对观众

mc.transform.matrix3D.prependRotation(-180/m*i,Vector3D.Y_AXIS);//绕轴自转

arr.push(mc); } }

var cf:ConvolutionFilter=new

ConvolutionFilter(3,3,[10,10,10,10,32,10,10,10,10],115); //卷积滤镜可以让颜色逐渐消失

addEventListener(Event.ENTER_FRAME ,f); function f(e) {

for (var i=0; iarr[i].transform.matrix3D.appendRotation(vx,Vector3D.Y_AXIS);

//同上面的道理，公转的速度为vx和vy那么自传相反的方向-vx和-vy arr[i].transform.matrix3D.prependRotation(-vx,Vector3D.Y_AXIS); arr[i].transform.matrix3D.appendRotation(vy,Vector3D.X_AXIS);

arr[i].transform.matrix3D.prependRotation(-vy,Vector3D.X_AXIS); }

arr.sortOn(\"z\代表降序排列 for (i=0; imap.draw(con);//不停的对容器拍照可以得到每个时刻的图像达到每个小球颜色拖延并逐渐消失的效果

map.applyFilter(map,map.rect ,new Point(0,0),cf); }

实例653d旋转时钟

function ball(r:int ,color:uint ):MovieClip { var mc:MovieClip =new MovieClip();

mc.graphics.beginGradientFill(GradientType.RADIAL ,[color,0xffffff],[1,1],[0,255]);

mc.graphics.drawCircle(0,0,r); return mc; }

function line(k:int ,a:Number ,b:Number ,color:uint ):MovieClip { //参数是线条粗细，起点坐标和终点的纵坐标坐标 var mc:MovieClip =new MovieClip(); mc.graphics.lineStyle(k,color); mc.graphics.moveTo(0,a); mc.graphics.lineTo(0,b);

mc.graphics.lineStyle(1,0x000000);

mc.graphics.drawCircle(0,0,2);//画的小圆点 return mc; }

var con:MovieClip =new MovieClip(); addChild(con); con.x=275;

con.y=200; con.z=0;

var arr:Array=[];//存放小球的数组 for (var i:int =0; i<12; i++) {

var mc1:MovieClip=ball(6,0x00ffff);//最里边的一层小球 var mc2:MovieClip=ball(10,0x333300);//中间的一层小球 var mc3:MovieClip=ball(6,0x00ffff);//最外边的一层小球 mc1.x=mc2.x=mc3.x=110*Math.cos(i*30*Math.PI/180); mc1.y=mc2.y=mc3.y=110*Math.sin(i*30*Math.PI/180); mc1.z=16; mc2.z=0; mc3.z=-16;

con.addChild(mc1); con.addChild(mc2); con.addChild(mc3); arr.push(mc1,mc2,mc3); }

var shizhen:MovieClip=line(5,5,-70,0x9900ff); var fenzhen:MovieClip=line(3,5,-80,0x9900ff); var miaozhen:MovieClip=line(2,10,-90,0xff0000); shizhen.z=2; fenzhen.z=0; miaozhen.z=-2;

var sp:MovieClip=new MovieClip();//存放刻度的容器 con.addChild(sp);//也全部放在大容器里 sp.z=2;

//var arrA:Array=[shizhen,miaozhen,fenzhen,kedu];// var kedu:MovieClip =new MovieClip(); sp.addChild(kedu);

kedu.z=3;//说明刻度在针的下面 sp.addChild(shizhen); sp.addChild(fenzhen); sp.addChild(miaozhen);

sp.filters=[new BevelFilter(2,45,0xffffff,1,0xffffff)]; for (i=0; i<60; i++) {

var kd:MovieClip=line(i%3==0?2:1,-93,-96,0x666666); //每隔三条细线画条较粗的 kedu.addChild(kd); kd.rotation=i*6; }

//添加文字

for (i=1; i<=12; i++) {

var txt:TextField =new TextField(); txt.text=\"\"+i;

txt.textColor=0x666666; kedu.addChild(txt); txt.autoSize=\"left\";

txt.x=85*Math.cos(i*30*Math.PI/180-Math.PI/2)-txt.width/2; //因为当i=1的时候第一个角度是30度那么按照顺时针方向30度的地方，而实际上钟表中的1在逆时针旋转60度的地方，

//因此才逆时针旋转90度，即减去个九十度

txt.y=85*Math.sin (i*30*Math.PI /180-Math.PI/2)-txt.height /2 ; }

var arrA:Array=[shizhen,miaozhen,fenzhen,kedu];// arr.push(sp);

addEventListener(Event.ENTER_FRAME ,frame); function frame(e) {

var mydate:Date =new Date(); var h=mydate.hours; var m=mydate.minutes; var s=mydate.seconds; shizhen.rotation=h*30+m*0.5; fenzhen.rotation=m*6+s*0.1; miaozhen.rotation=s*6;

var ang:Number =(mouseX-275)/10; //var ang0:Number =(mouseY-200)/50

//con.transform .matrix3D.appendRotation(ang,Vector3D.X_AXIS) //con.transform .matrix3D.appendRotation(ang0,Vector3D.Y_AXIS) for (i=0; iarr[i].transform.matrix3D.appendRotation(ang,Vector3D.Y_AXIS);

arr[i].transform.matrix3D.prependRotation(-ang,Vector3D.Y_AXIS); //每隔小球公转的同时让每个小球反方向自传，这样就可以让每个小球的证明面对观众

}//但是此时数组中还有钟面的原件也会反方向自传过来从而始终面对观众，看起来好像不转一样

//因此让钟面容器sp再转回去

sp.transform.matrix3D.prependRotation(ang,Vector3D.Y_AXIS); arr.sortOn(\"z\

for (i=0; iarr[i].transform.colorTransform=new ColorTransform(1,1,1,1,- arr[i].z,- arr[i].z);

//小球的颜色随着z坐标的改变而改变 }

for (i=0; iif (sp.z>0) {//设置时针秒针，分针的层深， sp.setChildIndex(arrA[i],i);

} else {

sp.setChildIndex(arrA[i],arrA.length -1-i); } }

con.z=- mouseY/400*150;

//利用z坐标的改变来达到大小改变的方法 }

实例66前后摇晃字体和旋转字体

var sp:Sprite=new Sprite(); addChild(sp);

sp.scaleX=sp.scaleY=scaleZ=1; sp.x=200; sp.y=-100; sp.z=200;

for (var i:int=0; i<5; i++) {

var mcc:MovieClip=new Mcc();//库中的一个文字元件 sp.addChild(mcc); mcc.x=10+i*2; mcc.y=10+i*2; mcc.z=i*1; }

addEventListener(Event.ENTER_FRAME,frame); function frame(e:Event) { for (var i:int=0; i<5; i++) { var mcc=sp.getChildAt(i);

mcc.transform.matrix3D.appendRotation(8,Vector3D.Y_AXIS);

mcc.transform.matrix3D.prependRotation(-8,Vector3D.Y_AXIS); mcc.transform.matrix3D.appendRotation(4,Vector3D.X_AXIS);

mcc.transform.matrix3D.prependRotation(-4,Vector3D.X_AXIS); } }

var sp:Sprite=new Sprite();//声明一个容器类实例sp addChild(sp);//把sp添加显示列表 sp.x=275 sp.y=200

var arr:Array=[];//声明一个空数组arr

var str:String=\"三叶草平安\";//声明一个字符串型变量str for (var i:int=0; i<4; i++) {//创建一个for循环，循环4次

var mc:MovieClip=new MovieClip();//声明一个影片剪辑类实例mc sp.addChild(mc);//把mc添加到sp中

mc.filters=[new DropShadowFilter(4,45)];//对mc应用投影滤镜（4像素，45度） var txt:TextField=new TextField();//声明一个文本类实例txt mc.addChild(txt);//把txt添加显示列表

txt.defaultTextFormat=new TextFormat(\"华文行楷\为txt设置文本格式（华文行楷，字号50,红色）

txt.text=str.substr(i,1);//文本的内容获取字符串str从第i个开始后的1个字符 mc.x=40*Math.cos(i*Math.PI/2);//mc的X坐标

mc.z=40*Math.sin(i*Math.PI/2);//mc的Z坐标,使这四个字分布在Ｘ轴与Ｚ轴所在的平面以（０,０）点为圆心，半径为５０的圆上 arr.push(mc);//把mc添加到数组arr中

mc.addEventListener(Event.ENTER_FRAME,f);//为mc添加帧频事件侦听，调用函数f }

function f(e) {//定义事件函数f

for (var i:int=0; i arr[i].transform.matrix3D.prependRotation(-1,Vector3D.Y_AXIS);//设置字的前置旋转（速度-1，围绕自己的Y轴） }

arr.sortOn(\"z\数组arr中元素根据Z坐标按降序排列

for (var n=0; n 实例67下落的数字流

function randomnum():TextField { var txt:TextField =new TextField(); txt.width=12;

txt.textColor=0x00ff00;

txt.addEventListener(Event.ENTER_FRAME ,f); function f(e) {

e.target.text=int(Math.random ()*10) }

return txt;}

function spnum():Sprite { var sp:Sprite =new Sprite();

for (var j:int=0; j<10; j++) { var txt:TextField=randomnum(); sp.addChild(txt); txt.y=j*30 ;}

return sp; }

function movenum():Sprite { var sp:Sprite=spnum(); addChild(sp);

sp.x=Math.random()*550;

sp.y=Math.random ()*(-250); sp.alpha=Math.random()+.1;

sp.scaleX=sp.scaleY=Math.random()*.5+1;

sp.addEventListener(Event.ENTER_FRAME ,movef); function movef(e) {

sp.y+=Math.random()*5+5; if (sp.y>400) {

sp.x=Math.random()*550;

sp.y=Math.random ()*(-250) } }

return sp;} var i:int=0

addEventListener(Event.ENTER_FRAME ,frame) function frame(e){ var sp:Sprite =movenum() addChild(sp) i++

if(i==40){

removeEventListener(Event.ENTER_FRAME ,frame) } }

实例68 硬币绕硬币旋转

var sp:Sprite =new Sprite();//用来存放两个圆的容器 addChild(sp); sp.x=275; sp.y=200;

function yuan(color:uint ,r:Number ,clo:uint):MovieClip { var mc:MovieClip =new MovieClip(); sp.addChild(mc);

mc.filters =[new BevelFilter()]; mc.graphics.lineStyle(1,color);

mc.graphics.beginFill(color,1);

mc.graphics.drawCircle(0,0,r);//画圆 mc.graphics.endFill();

mc.graphics.beginFill(0x000000);//画小圆点作为圆心 mc.graphics.drawCircle(0,0,5); mc.graphics.endFill(); mc.graphics.beginFill(clo);

mc.graphics.drawCircle(-r,0,5);//画一个左边小圆作为旋转参考标记 mc.graphics.endFill(); return mc; }

var rDing:Number=Number(txtDing.text);//场景中定圆半径输入文本 var rDong:Number=Number(txtDong.text);//动圆半径

var l:Number =1*Math.PI *(rDing+rDong)/180;//计算外圆圆心每转动一度的弧长 //计算这个弧长相对于外圆来说应该转过的角度

var rot:Number=l*180/(Math.PI *rDong);//这个控制动圆自身的旋转角速度 var ang:int=0;//.这个是控制外圆圆心绕定圆圆心旋转的角度 var yuanDong:MovieClip=yuan(0xff0000,rDong,0xff0000); var yuanDing:MovieClip=yuan(0x00ffff,rDing,0xff00ff); yuanDing.x=0; yuanDing.y=0;

yuanDong.x=yuanDing.x+rDing+rDong; yuanDong.y=yuanDing.y;

txtDong.addEventListener(Event.CHANGE ,cf); txtDing.addEventListener(Event.CHANGE ,cf); stage.addEventListener(MouseEvent.CLICK ,cf); function cf(e) {

while (sp.numChildren >0) { sp.removeChildAt(0); }

rDong=Number(txtDong.text);//当改变文本参数时候要重新刷新的数值 //动圆半径定圆半径，宣传的角速度，旋转角度归零 rDing=Number(txtDing.text);

yuanDong=yuan(0xff0000,rDong,0xff0000);//场景中一个动圆和一个定圆 yuanDing=yuan(0x00ffff,rDing,0xff00ff); yuanDing.x=0; yuanDing.y=0;

yuanDong.x=yuanDing.x+rDing+rDong; yuanDong.y=yuanDing.y;

l =1*Math.PI *(rDing+rDong)/180;//计算外圆圆心每转动一度的弧长 //计算这个弧长相对于外圆来说应该转过的角度

rot=l*180/(Math.PI *rDong);//这个控制动圆自身的旋转角速度 ang=0;

addEventListener(Event.ENTER_FRAME ,ff);

}

function ff(e) {

yuanDong.rotationZ+=rot;

yuanDong.x=yuanDing.x+(rDong+rDing)*Math.cos (ang*Math.PI /180);

yuanDong.y=yuanDing.y+(rDong+rDing)*Math.sin (ang*Math.PI /180); //这个即是动圆应该转过的角速度 ang++; }

实例69 变换的彩色火焰效果

//圆的参数方程

[SWF(width=550,height=500,frameRate=30)] stage.frameRate=30; var px:Number; var py:Number; var angle:Number;

var R:Number=100;//外圆半径 var r:Number=30;//内圆半径 var i:int=0; var col:uint; var m:int=0;

var c:Object={r:-5,g:-5,b:-20}; var sp:Sprite=new Sprite(); sp.x=stage.stageWidth/2; sp.y=stage.stageHeight/2;

sp.graphics.lineStyle(1,0xffffff); //sp.filters=[new GlowFilter()] addChild(sp);

for (i=0; i<360*8; i++) { angle=i*Math.PI/180;

myrot();//圆的参数方程的自定义函数 if (i==0) {

sp.graphics.moveTo(px,py); } else {

sp.graphics.lineTo(px,py); } }

var ball:Ball=new Ball(); sp.addChild(ball);

ball.cacheAsBitmap=true;

//如果设置为 true，则 Flash Player 将缓存显示对象的内部位图表示形式。用该属性往往比默认使用矢量能够更快地呈现。 function myrot():Number {

px=(R+r)*Math.cos(angle)+r*Math.cos((R-r)/r*angle);

使 py=(R+r)*Math.sin(angle)-r*Math.sin((R-r)/r*angle); return px; return py; }

//创建布林噪波位图

var map1:BitmapData=new BitmapData(550,500,false,0); var map2:BitmapData=new BitmapData(550,500,false,0); map2.perlinNoise(10,160,2,10,true,true,1,true); var perMc:Sprite=new Sprite();//装有杂点容器 var con1:Sprite=new Sprite();//父容器 var con:Sprite=new Sprite();//小容器 addChild(con);

con.addChild(sp);//装画的圆 con1.addChild(perMc);

var perBit:Bitmap=new Bitmap(map2); perMc.addChild(perBit);

addChild(new Bitmap(map1));//场景上的底图 var bit:Bitmap=new Bitmap(map2);

bit.blendMode=BlendMode.OVERLAY;//与底色<50%变暗 addEventListener(Event.ENTER_FRAME,frame); function frame(e):void { angle=i%720*Math.PI/180; myrot(); ball.x=px; ball.y=py; i+=2;

sp.rotation++;

map1.draw(con);//小圆环

map2.draw(con1);//有布林杂点的图

map1.applyFilter(map1,map1.rect,new Point(),new BlurFilter(2,2,1));

map1.colorTransform(map1.rect,new ColorTransform(1,1,1,1,c.r,c.g,c.b)); map1.draw(map1.clone(),new Matrix(1,0,0,1,0,-2)); m++;

switch (m%300) { case 50 : c.g=c.b; break; case 100 :

c.r=c.b,c.g=c.b=-5; break; case 150 : c.b=-20; break;

case 200 :

c.g=-20,c.r=c.b=-5; break; case 250 : c.r=c.g; break; case 0 :

c.r=c.g=-5,c.b=-20; break; } }

setChildIndex(mc,numChildren-1)

实例70 分形几何的研究-----1、带果实的分形树

[SWF(width = 600,height = 600)] var N:int = 14;

var startAng:int = 20; var startLen:int = 70;

var color:uint = 0x663300; var size:int = 7; //画树干或树枝

function line(ax,ay,bx,by,color,size) {

size < 1 ? 1:0;//如果小于1就取1,否则什么也不画 graphics.lineStyle(size,color); graphics.moveTo(ax,ay); graphics.lineTo(bx,by); }

//画果实;

function cir(ax,ay,color,r) { graphics.lineStyle();

graphics.beginFill(color); graphics.drawCircle(ax,ay,r); }

function tree(oldx,oldy,ang,len,color,size,n) { //递归 出口，大于这个参数，停止绘制 if (n < N) {

var newx = oldx + len * Math.cos(ang * Math.PI / 180);

var newy = oldy + len * Math.sin(ang * Math.PI / 180);//进一步判断，最后一次 画园=果实

if (n == N - 1) {//颜色进行判断：开始树叶，<0,5 黄色，否则 红色

color = Math.random() < .99 ? 0x009900:(Math.random() < .5 ?0xff9900:0xff0000);//是绿色0x009900 r=2,否则r=4

var r:int = color == 0x009900 ? 2:4; cir(oldx,oldy,color,r); } else {

line(oldx,oldy,newx,newy,color,size); }

var angL = ang - startAng; var angR = ang + startAng;

tree(newx,newy,angL,(Math.random()*.5+.5)*len,color,size-=0.5,n+1); tree(newx,newy,angR,(Math.random()*.5+.5)*len,color,size-=0.5,n+1); } }

tree(stage.stageWidth/2,stage.stageHeight,-90,startLen,color,size,1); stage.addEventListener(MouseEvent.CLICK,click); function click(e:MouseEvent) { graphics.clear();

tree(stage.stageWidth/2,stage.stageHeight,-90,startLen,color,size,1); }

实例71 分形的研究-----点击场景看分形树

function line(ax,ay,bx,by) {//画线函数 this.graphics.lineStyle(2,0xff0000); this.graphics.moveTo(ax,ay); this.graphics.lineTo(bx,by); }

var n:int=0;//控制递归出口的参数 var num:int=8;//画线分支的条数

function pic(x0,y0,len,ang,n,num) {//参数，中心坐标，长度，中心所在角度，n控制递归的次数，画线的分支数目 if (n>0) {//

for (var i:int=0; ivar x1:Number =x0+len*Math.cos ((ang+360/num*i)*Math.PI /180);//计算每个分支末端的坐标

var y1:Number =y0+len*Math.sin ((ang+360/num*i)*Math.PI /180); line(x0,y0,x1,y1);//从中心开始向末端画线

pic(x1,y1,0.3*len,ang,n-1,num);//再次调用该函数，注意此时上次末端变成了起点并且让长度缩小0.3倍 } } }

pic(275,200,100,-90,5,num);

stage.addEventListener(MouseEvent.CLICK ,f);

function f(e) { graphics.clear();

num=Math.ceil(Math.random()*5)+3; pic(275,200,100,-90,5,num); }

实例72 分形的研究-----四方内生树

var c:Number=5;//距离

function koch(ax:Number ,ay:Number ,bx:Number ,by:Number ) { if (Math.sqrt ((bx-ax)*(bx-ax)+(by-ay)*(by-ay))//利用线段的长度控制的递归次数:当小段小于5结束递归画图 graphics.lineStyle(2,0xffffff*Math.random()); graphics.moveTo(ax,ay); graphics.lineTo(bx,by); } else {

var cx:Number =ax+2/3*(bx-ax); var cy:Number =ay+2/3*(by-ay); var ex:Number =ax+1/3*(bx-ax); var ey:Number =ay+1/3*(by-ay);

var len:Number =Math.sqrt ((bx-ax)*(bx-ax)+(by-ay)*(by-ay));

var ang:Number=Math.atan2(by-cy,bx-cx);//b点相对于c点的倾斜角因为点d //要b点以c为圆心逆时针旋转90

var dx:Number=cx+1/3*len*Math.cos(ang+Math.PI/2);//逆时针的角度是负

var dy:Number=cy+1/3*len*Math.sin(ang+Math.PI/2);//这是计算第三个点的坐标 koch(ax,ay,ex,ey);//线段ae koch(ex,ey,cx,cy);//线段ec koch(cx,cy,dx,dy);//线段cd koch(dx,dy,cx,cy);//回画线段dc koch(cx,cy,bx,by);//线段cb

//注意画线段的长短不同条数不同就会得到不同的效果 } }

function initf() { koch(100,50,500,50); koch(500,50,500,450); koch(500,450,100,450); koch(100,450,100,50); }

addEventListener(Event.ENTER_FRAME ,ff); addbtn.addEventListener(MouseEvent.CLICK ,f); subbtn.addEventListener(MouseEvent.CLICK ,f); function f(e) {

if (e.target.name==\"addbtn\") { c<=400?c+=15:0;

} else {

c>5?c-=15:0; }

addEventListener(Event.ENTER_FRAME ,ff); }

function ff(e) { graphics.clear(); initf(); }

实例73 分形的研究-----被风吹的树

var N=5;

function koch(ax:Number ,ay:Number ,bx:Number ,by:Number,size,n ) { if (n>N) {

//控制迭代次数出口

graphics.lineStyle(size,0x009900); graphics.moveTo(ax,ay); graphics.lineTo(bx,by); } else {

var cx:Number =ax+2/3*(bx-ax); var cy:Number =ay+2/3*(by-ay); var ex:Number =ax+1/3*(bx-ax); var ey:Number =ay+1/3*(by-ay);

var len:Number =Math.sqrt ((bx-ax)*(bx-ax)+(by-ay)*(by-ay));

var ang:Number=Math.atan2(by-cy,bx-cx);//b点相对于c点的倾斜角因为点d //要b点以c为圆心逆时针旋转90

var dx:Number=cx+3/4*len*Math.cos(ang-Math.PI/2*Math.random());//逆时针的角度是负

var dy:Number=cy+3/4*len*Math.sin(ang-Math.PI/2*Math.random());// var fx:Number=ex+1/6*len*Math.cos(ang+Math.PI/2*Math.random());// var fy:Number=ey+1/6*len*Math.sin(ang+Math.PI/2*Math.random()); size=size/(n+1);

koch(ax,ay,ex,ey,size,n+1);//线段ae koch(ex,ey,cx,cy,size,n+1);//线段ec koch(cx,cy,dx,dy,size,n+1);//线段cd koch(ex,ey,fx,fy,size,n+1);//回画线段dc koch(cx,cy,bx,by,size,n+1);//线段cb

//注意画线段的长短不同条数不同就会得到不同的效果 } }

function initf() {

koch(300,550,300,50,5,0); }

addEventListener(Event.ENTER_FRAME ,ff);

addbtn.addEventListener(MouseEvent.CLICK ,f); subbtn.addEventListener(MouseEvent.CLICK ,f); function f(e) {

if (e.target.name==\"addbtn\") { N<=4?N++:0; } else { N>0?N--:0; }

addEventListener(Event.ENTER_FRAME ,ff); }

function ff(e) { graphics.clear(); initf();}

实例74 分形的研究-----柯赫曲线

//场景中有个addbtn和subbtn按钮和一个txt文本框 txt.autoSize=\"left\"

var scy:String=\"F-F++F-F\";//定义生成法则

var axiom:String=\"F\";//初始定义一个生成元

//如果改成F++F++F则可以变成初始元为三角形迭代结果为雪花 var n:int=4;//定义迭代次数

var ang:Number=0;//初始旋转角度

var offsetA:Number=60;//角度偏移的角度 var len:Number=450;//起点到终点的长度

var d:Number=len*Math.pow(4/3,n)/Math.pow(4,n);//每一段的长度 //======定义迭代生成过程函数 function makeStr(n) {//

for (var m:int=0; mvar tempStr:String=\"\";//声明一个临时字符串用来装生成的迭代n次地字符串 var j:int=0;//用来查找字符串中的第j个字符 while (jvar s:String=axiom.substr(j,1);

if (s==\"F\") {//如果查找到的是F则让临时字符串添加一个生成元 tempStr+=scy ;

} else {//如果查找到是+或者减号那么直接添加到临时字符串 tempStr+=s; }

j++; }

axiom=tempStr;//每次迭代后把临时字符串重新赋给生成过程字符串里 } }

function drawkoch(x0:Number,y0:Number ) { graphics.lineStyle(3,0x000000); graphics.moveTo(x0,y0); var x1:Number=0; var y1:Number=0; var i:int=0;

while (ivar s:String=axiom.substr(i,1);//截取 switch (s) {

case \"F\" ://如果F就划线

x1=x0+d*Math.cos(ang*Math.PI/180); y1=y0+d*Math.sin(ang*Math.PI/180); graphics.lineTo(x1,y1); x0=x1; y0=y1; break;

case \"+\" ://如果＋就顺时针旋转60 ang+=offsetA; break;

case \"-\" ://如果是减号就逆时针旋转60 ang-=offsetA; break;} i++; } }

makeStr(n);

drawkoch(50,200);

addbtn.addEventListener(MouseEvent.CLICK ,f); subbtn.addEventListener(MouseEvent.CLICK ,f); function f(e) { graphics.clear();

if (e.target.name==\"addbtn\") { n<=4?n++:0; } else { n>0?n--:0; }

axiom=\"F\" ang=0

d=len*Math.pow(4/3,n)/Math.pow(4,n)

makeStr(n);

drawkoch(50,200); txt.text=axiom }

实例75 分形的研究-----丢勒的五边形

//==========画正多边形

function duobianxing(N:int,R:Number,X:Number,Y:Number ,ang:Number ) { //参数为正多边形的边数，半径和中心坐标 多边形起点的倾斜角 graphics.lineStyle(2,0xffffff*Math.random ()); graphics.beginFill(0xffffff*Math.random ());

graphics.moveTo(X+R*Math.cos(ang),Y+R*Math.sin(ang)); for (var i:int=0; i//用if。。。else语句的写法控制迭代出口的特点是只显示出最终迭代效果也就是用下次迭代的图形代替了前面的图形也就是上次迭代的图形没有了

//只if语句控制迭代出口的特点则是添加即下次迭代的图形添加到了上次迭代的图形中，例如写法三所以其实里面重复了很多图形 var N:int=3;//初始迭代次数 var num=5;//正多边形的边数

var rr:Number=200;//初始最大正多边形的半径 //============迭代过程函数

function diedai(m:int,r:Number,x0:Number ,y0:Number,ang,n:int) { //ang是较大的多边形的起点倾斜角

if (n==N) {//迭代函数的出口，当n=5时则结束迭代函数画五边形 duobianxing(m,r,x0,y0,ang);//

} else {//再画里面的六个小正五边形

var newr:Number=r*Math.sin (36*Math.PI /180)/(1+Math.cos (72*Math.PI /180))/2/Math.sin (36*Math.PI /180);

//计算这些小多边形的半径即引导层中A0长度

diedai(m,newr,x0,y0,ang-Math.PI /5,n+1);//先把中间的小五边形迭代注意它的起始点倾斜角要在原来的ang基础上 //逆时针旋转半个中心角

for (var j:int=0; j<5; j++) {//计算周围五个小正五边形所在圆的圆心 var newx:Number=x0+(r-newr)*Math.cos (ang+j*Math.PI*2 /5);

var newy:Number=y0+(r-newr)*Math.sin (ang+j*Math.PI*2 /5);

var ang0:Number=Math.atan2(newy-y0,newx-x0);//每个小五边形和中间较大的五边形重合的顶点相对于小五边形

//中心的倾斜角和小五边形的中心相对于大五边形的中心的倾斜角是相同的因为三点共线切方向相同所以，把这个角度作为

//作为每个小五边形的起始点倾斜角绘制五个小五边形 diedai(m,newr,newx,newy,ang0,n+1);

////较小的正多边形的中心坐标和半径又作为下次迭代较大的正多边形的中心和半径，注意此时要把ang0逆时针旋转一个中心角

////作为新的较大的正多边形的起始顶点的倾斜角， } } }

//==============迭代生成效果

addEventListener(Event.ENTER_FRAME ,frame); addbtn.addEventListener(MouseEvent.CLICK ,clf); subbtn.addEventListener(MouseEvent.CLICK ,clf); function clf(e) {

if (e.target.name==\"addbtn\") { N<8?N++:0;//迭代次数小于5 }

if (e.target.name==\"subbtn\") { N>0?N--:0; }

addEventListener(Event.ENTER_FRAME ,frame);

//不直接调用initf函数而添加帧频函数调用的好处是可以时刻改变颜色达到绚丽的效果 }

function frame(e) { graphics.clear();

diedai(num,200,300,300,Math.PI /2-Math.PI /num,0); }

实例76 分形的研究-----丢勒的五边形二

//==========画正多边形

function duobianxing(N:int,R:Number,X:Number,Y:Number ,ang:Number ) { //参数为正多边形的边数，半径和中心坐标 多边形起点的倾斜角 graphics.lineStyle(2,0xffffff*Math.random ()); graphics.beginFill(0xffffff*Math.random ());

graphics.moveTo(X+R*Math.cos(ang),Y+R*Math.sin(ang)); for (var i:int=0; i} }

var N:int=3;//初始迭代次数 var num=5;//正多边形的边数

var rr:Number=200;//初始最大正多边形的半径 //============迭代过程函数

function diedai(m:int,r:Number,x0:Number ,y0:Number,ang,n:int) { //ang是较大的多边形的起点倾斜角 if (n==N) {//===先画外边最大的正方形 duobianxing(m,r,x0,y0,ang);//

} else {//再画里面的五个小正五边形

var newr:Number=r*Math.sin (36*Math.PI /180)/(1+Math.cos (72*Math.PI /180))/2/Math.sin (36*Math.PI /180);

//计算这些小多边形的半径即引导层中A0长度

for (var j:int=0; j<5; j++) {//计算五个小正五边形所在圆的圆心 var newx:Number=x0+(r-newr)*Math.cos (ang+j*Math.PI*2 /5); var newy:Number=y0+(r-newr)*Math.sin (ang+j*Math.PI*2 /5);

var ang0:Number=Math.atan2(newy-y0,newx-x0);//每个小五边形和中间较大的五边形重合的顶点相对于小五边形

//中心的倾斜角和小五边形的中心相对于大五边形的中心的倾斜角是相同的因为三点共线切方向相同所以，把这个角度作为

//作为每个小五边形的起始点倾斜角绘制五个小五边形 diedai(m,newr,newx,newy,ang0,n+1);

////较小的正多边形的中心坐标和半径又作为下次迭代较大的正多边形的中心和半径，注意此时要把ang0逆时针旋转一个中心角

////作为新的较大的正多边形的起始顶点的倾斜角， } } }

addEventListener(Event.ENTER_FRAME ,frame); addbtn.addEventListener(MouseEvent.CLICK ,clf); subbtn.addEventListener(MouseEvent.CLICK ,clf); function clf(e) {

if (e.target.name==\"addbtn\") { N<8?N++:0;//迭代次数小于5} if (e.target.name==\"subbtn\") { N>0?N--:0; }

addEventListener(Event.ENTER_FRAME ,frame);

//不直接调用initf函数而添加帧频函数调用的好处是可以时刻改变颜色达到绚丽的效果 }

function frame(e) { graphics.clear();

diedai(num,200,300,300,Math.PI /2-Math.PI /num,0)}

实例77 分形的研究-----谢尔宾斯基三角形地毯

var N:int=5;

var scale:Number=0.6;//三角形边长缩小比例

//====先得到中间的最大的三角形注意这个三角形不参与迭代 var R:Number=100;//中间最大的三角形的半径 var W=stage.stageWidth/2; var H=stage.stageHeight/2; //=======画三角形

function sanjiaoxing(x1:Number,y1:Number,x2:Number ,y2:Number ) {//三角形左上 角的坐标，和三角形右上角的坐标

graphics.lineStyle(1,0xffffff*Math.random());

graphics.moveTo(x1,y1);//先画三角形上边的一条线 graphics.beginFill(0xffffff*Math.random()); graphics.lineTo(x2,y2);

//计算三角形的边长可以用两点间的距离公式，也可以用点的距离属性 var len:Number=Point.distance(new Point(x1,y1),new Point(x2,y2));

var ang:Number=Math.atan2(y2-y1,x2-x1);//计算右上角的点相对于左上角的倾斜角 var x3:Number=x1+len*Math.cos(ang+1/3*Math.PI);//得到下面的顶点坐标 var y3:Number=y1+len*Math.sin(ang+1/3*Math.PI); graphics.lineTo(x3,y3); graphics.lineTo(x1,y1); graphics.endFill(); }

function diedai(x0:Number ,y0:Number ,xx:Number ,yy:Number ,n:int ) { ///初始参数分别是第一个三角形的左上角的坐标和右上角的坐标 if (n//先画下面的三角形 sanjiaoxing(x0,y0,xx,yy);

//======计算左上角的三角形的左上顶点 //先计算上面的三角形的边长

var l:Number=Point.distance(new Point(x0,y0),new Point(xx,yy)); //得到两个左上角和右上角的三角形边长 var newl:Number=l*scale;

//计算上面三角形右上角相对于左上角定点的倾斜角 var a:Number=Math.atan2(yy-y0,xx-x0); //得到左上角的三角形的一个顶点

var X0:Number=x0+newl*Math.cos(a-120*Math.PI/180);

var Y0:Number=y0+newl*Math.sin(a-120*Math.PI/180);

//把这个点和原三角形的左上角顶点当成左上三角形的两个参数顶点得到左上角三角形

sanjiaoxing(X0,Y0,x0,y0);

var b:Number=Math.atan2(y0-yy,x0-xx);//计算上面三角形左上角相对于右上角顶点的倾斜角

//得到右上三角形的一个顶点：是以原三角形的右上点为圆心以newl为半径的圆的参数方程

//即在倾斜角b的基础上顺时针旋转120

var X:Number=xx+newl*Math.cos(b+120*Math.PI/180); var Y:Number=yy+newl*Math.sin(b+120*Math.PI/180); sanjiaoxing(xx,yy,X,Y);

//分别计算左上三角形与右上三角形的第三个顶点

var x3:Number=x0+newl*Math.cos(a-180*Math.PI/180); var y3:Number=y0+newl*Math.sin(a-180*Math.PI/180); var xx3:Number=xx+newl*Math.cos(b-180*Math.PI/180); var yy3:Number=yy+newl*Math.sin(b-180*Math.PI/180); diedai(x3,y3,X0,Y0,n+1); diedai(X,Y,xx3,yy3,n+1); } }

//====通过循环得到最终迭代效果 function initf() {

for (var i:int =0; i<3; i++) {

var xxx:Number=W+R*Math.cos(i*2/3*Math.PI+1/6*Math.PI);//因为保证下面一条边水平所以要顺时针旋转30

var yyy:Number=H+R*Math.sin(i*2/3*Math.PI+1/6*Math.PI);

var x1=xxx+Math.sqrt(3)*R/2*Math.cos(0*1/3*Math.PI+i*2/3*Math.PI); var y1=yyy+Math.sqrt(3)*R/2*Math.sin(0*1/3*Math.PI+i*2/3*Math.PI); var x2=xxx+Math.sqrt(3)*R/2*Math.cos(1*1/3*Math.PI+i*2/3*Math.PI); var y2=yyy+Math.sqrt(3)*R/2*Math.sin(1*1/3*Math.PI+i*2/3*Math.PI); diedai(x1,y1,x2,y2,0); } }

//======最后画出中间的最大三角形 function dasanjiaoxing() {

graphics.moveTo(W+R*Math.cos(1/6*Math.PI),H+R*Math.sin(1/6*Math.PI)); graphics.beginFill(0xffffff*Math.random ()); for (var i =0; i<3; i++) {

var d=W+R*Math.cos((i+1)*2/3*Math.PI+1/6*Math.PI);//因为保证下面一条边水平所以要顺时针旋转30

var c=H+R*Math.sin((i+1)*2/3*Math.PI+1/6*Math.PI); graphics.lineTo(d,c); }

}

/addEventListener(Event.ENTER_FRAME ,frame); addbtn.addEventListener(MouseEvent.CLICK ,clf); subbtn.addEventListener(MouseEvent.CLICK ,clf); function clf(e) {

if (e.target.name==\"addbtn\") { N<8?N++:0;//迭代次数小于5 }

if (e.target.name==\"subbtn\") { N>0?N--:0; }

addEventListener(Event.ENTER_FRAME ,frame);

//不直接调用initf函数而添加帧频函数调用的好处是可以时刻改变颜色达到绚丽的效果 }

function frame(e) { graphics.clear(); initf();

dasanjiaoxing(); }

实例78 分形的研究-----谢尔宾斯基任意正多边形地毯

//画=====正方形

function duobianxing(N:int,R:Number,X:Number,Y:Number ,ang:Number ) { //参数为正多边形的边数，半径和中心坐标 多边形起点的倾斜角 graphics.lineStyle(2,0xffffff*Math.random ()); graphics.beginFill(0xffffff*Math.random ());

graphics.moveTo(X+R*Math.cos(ang),Y+R*Math.sin(ang)); for (var i:int=0; ivar N:int=4;//初始迭代次数 var num=3;//正多边形的边数

var rr:Number=100;//初始最大正多边形的半径 var scale:Number=0.6;//正多边形的边长缩小比例

function diedai(m:int,r:Number,x0:Number ,y0:Number,ang,n:int) { //ang是较大的多边形的起点倾斜角 if (n//===========再画周围的m-1个较小的正多边形 var newr:Number=r*scale;//计算这些小多边形的边长

for (var j:int=0; j//计算它们的中心位置，以较大的中心为圆心，以r+scaler为半径的圆周上 var newx:Number=x0+(1+scale)*r*Math.cos(ang-j*Math.PI*2/m); var newy:Number=y0+(1+scale)*r*Math.sin(ang-j*Math.PI*2/m);

//因为每个小正多边形的中心和大正多边形的中心以及它们连接的顶点都在一条直线上，

//因此连接点相对于大正多边形的倾斜角与连接点相对于每个小正多边形的倾斜角是互补的

//所以用180减去每个连接点的倾斜角ang-j*Math.PI*2/m则是连接

点相对于小正方形的倾斜角然后把这个角度作为起始角，画出小正多边形 duobianxing(m,newr,newx,newy,Math.PI-(ang-j*Math.PI*2/m));

var ang0:Number=Math.atan2(y0-newy,x0-newx);//重新计算较大正方形的中心相对于每个小正多边形中心的倾斜角

diedai(m,newr,newx,newy,ang0-Math.PI*2/m,n+1);

//较小的正多边形的中心坐标和半径又作为下次迭代较大的正多边形的中心和半径，注意此时要把ang0逆时针旋转一个中心角

//作为新的较大的正多边形的起始顶点的倾斜角， } } }

//==============迭代生成效果 function initf() {

duobianxing(num,rr,300,300,0);//先画中间的大正多边形//因为场景是600×600中心是300,300

for (var k:int =0; kvar xxx:Number=300+(1+scale)*rr*Math.cos(k*Math.PI*2/num);//大半径是100所100+38=150

var yyy:Number=300+(1+scale)*rr*Math.sin(k*Math.PI*2/num);//得到四个小正方形的顶点

var ang:Number=Math.atan2(300-yyy,300-xxx);

//计算中间的最大正多边形相对于每个小正多边形的中心的倾斜角，因为这两个中心和它们的连接顶点 //在一条直线上，因次也是每个连接顶点相对于每个小正多边形的倾斜角所以把这个倾斜角逆时针旋转一个中心角度

//作为迭代函数中较大正多边形的起始顶点倾斜角

diedai(num,scale*rr,xxx,yyy,ang-Math.PI*2/num,0);//分别作为迭代参数调用迭代函数 } }

addEventListener(Event.ENTER_FRAME ,frame); addbtn.addEventListener(MouseEvent.CLICK ,clf); subbtn.addEventListener(MouseEvent.CLICK ,clf); addnum.addEventListener(MouseEvent.CLICK ,clf); subnum.addEventListener(MouseEvent.CLICK ,clf);

function clf(e) {

if (e.target.name==\"addbtn\") { N<8?N++:0;//迭代次数小于5 }

if (e.target.name==\"subbtn\") { N>0?N--:0; }

if (e.target.name==\"addnum\") {

num<10?num++:0;//迭代次数小于10

num>0&&num<6?scale-=.1:0;//三四五变形边长缩小率减小的快些-0.1 num>=6&&num<10?scale-=.05:0;//六变形以上缩小率较小的慢些-0.05 }

if (e.target.name==\"subnum\") { num>0?num--:0;

num>=6&&num<10?scale+=.05:0 num>0&&num<6?scale+=.1:0 }

addEventListener(Event.ENTER_FRAME ,frame);

//不直接调用initf函数而添加帧频函数调用的好处是可以时刻改变颜色达到绚丽的效果 }

function frame(e) { graphics.clear(); initf(); }

实例79 分形的研究-----风雨坚强中的小草

//这种迭代方法的缺点是体现不出过程而只有最终结果例如，size没有变化过程只有最终迭代的结果数值

//却得不到由粗到细的变化过程 var N=4;

function koch(ax:Number ,ay:Number ,bx:Number ,by:Number,size,n ) { if (n>N) {

//控制迭代次数出口

graphics.lineStyle(size,0x009900); graphics.moveTo(ax,ay); graphics.lineTo(bx,by); } else {

var cx:Number =ax+2/3*(bx-ax); var cy:Number =ay+2/3*(by-ay); var ex:Number =ax+1/3*(bx-ax); var ey:Number =ay+1/3*(by-ay);

var len:Number =Math.sqrt ((bx-ax)*(bx-ax)+(by-ay)*(by-ay));

var ang:Number=Math.atan2(by-cy,bx-cx);//b点相对于c点的倾斜角因为点d

//要b点以c为圆心逆时针旋转90 var ang0:Number=Math.PI/6;

var dx:Number=cx+3/4*len*Math.cos(ang-ang0*Math.random());//逆时针的角度是负 var dy:Number=cy+3/4*len*Math.sin(ang-ang0*Math.random());// var fx:Number=ex+1/6*len*Math.cos(ang+ang0*Math.random());// var fy:Number=ey+1/6*len*Math.sin(ang+ang0*Math.random()); size=size/(n+1);

koch(ax,ay,ex,ey,size,n+1);//线段ae koch(ex,ey,cx,cy,size,n+1);//线段ec koch(cx,cy,dx,dy,size,n+1);//线段cd koch(ex,ey,fx,fy,size,n+1);//回画线段ef koch(cx,cy,bx,by,size,n+1);//线段cb

//注意画线段的长短不同条数不同就会得到不同的效果 } }

function initf() {//生成十五课小草 for (var j:int =0; j<15; j++) {

koch(j*50,550,-50*Math.random()+j*50,100*Math.random()+350,5,0); } }

addEventListener(Event.ENTER_FRAME ,ff); addbtn.addEventListener(MouseEvent.CLICK ,f); subbtn.addEventListener(MouseEvent.CLICK ,f); function f(e) {

if (e.target.name==\"addbtn\") { N<=4?N++:0; } else { N>0?N--:0; }

addEventListener(Event.ENTER_FRAME ,ff); }

function ff(e) { graphics.clear(); initf(); xiayu(); }

function xiayu() {//下雨

for (var k:int=0; k<100; k++) { graphics.lineStyle(1,0xffffff,.4);

var xx:Number=800*Math.random()-50; var yy=600*Math.random(); var x0:Number=xx-10; var y0:Number=yy+10; graphics.moveTo(xx,yy);

graphics.lineTo(x0,y0); } }

实例80 分形的研究-----风雨坚强中的小草二

//逐步迭代得到变化过程的效果例如粗细，透明度 var N=5; function

line(x1:Number ,y1:Number ,x2:Number ,y2:Number ,size:Number ,alp:Number ) { graphics.lineStyle(size,0x009900,alp); graphics.moveTo(x1,y1); graphics.lineTo(x2,y2); }

function koch(ax:Number ,ay:Number ,size, len,ang,alp,n ) {

if (nvar fx:Number=ex+1/6*len*Math.cos(ang-ang0*Math.random());// var fy:Number=ey+1/6*len*Math.sin(ang-ang0*Math.random()); var cx:Number=ax+len*Math.cos(ang); var cy:Number=ay+len*Math.sin(ang);

//var len:Number =Math.sqrt ((bx-ax)*(bx-ax)+(by-ay)*(by-ay));

var dx:Number=cx+1/4*len*Math.cos(ang+ang0*Math.random());//逆时针的角度是负 var dy:Number=cy+1/4*len*Math.sin(ang+ang0*Math.random());// line(ax,ay,ex,ey,size,alp);//线段ab line(ex,ey,cx,cy,size,alp);//ce line(ex,ey,fx,fy,size,alp);//线段ef line(cx,cy,dx,dy,size,alp);//线段cd

var ang1:Number=Math.atan2(fy-ey,fx-ex); var ang2:Number=Math.atan2(dy-cy,dx-cx); koch(ex,ey,size*.8,len*.8,ang,alp*.5,n+1 ); koch(ax,ay,size*.8,len*.8,ang,alp*.5,n+1 ); koch(ex,ey,size*.8,len*.8,ang1,alp*.5,n+1 ); koch(cx,cy,size*.8,len*.8,ang2,alp*.5,n+1 );

//注意画线段的长短不同条数不同就会得到不同的效果 } }

function initf() {//生成十五课小草 for (var k:int =0; k<10; k++) {

koch(k*50+50,500,1*Math.random()+2,50*Math.random()+30,-Math.PI/ 2,1,0); }

}

addEventListener(Event.ENTER_FRAME ,ff); addbtn.addEventListener(MouseEvent.CLICK ,f); subbtn.addEventListener(MouseEvent.CLICK ,f); function f(e) {

if (e.target.name==\"addbtn\") { N<=4?N++:0; } else { N>0?N--:0; }

addEventListener(Event.ENTER_FRAME ,ff); }

function ff(e) { graphics.clear(); initf(); xiayu(); }

function xiayu() {//下雨

for (var k:int=0; k<100; k++) { graphics.lineStyle(1,0xffffff,.4);

var xx:Number=800*Math.random()-50; var yy=600*Math.random(); var x0:Number=xx+10;// var y0:Number=yy+10; graphics.moveTo(xx,yy); graphics.lineTo(x0,y0);}}

实例81 分形的研究-----皇冠帽

var N:Number=3;// var len:Number;

function line(ax,ay,bx,by) {

graphics.lineStyle(2,0xffffff*Math.random ()); graphics.moveTo(ax,ay); graphics.lineTo(bx,by);} //======

function longquxian(ax:Number ,ay:Number ,bx:Number ,by:Number,n ) { if (n>N) {

line(ax,ay,bx,by); } else {

var ab=Point.distance(new Point(ax,ay),new Point(bx,by)); var ac=ab/2/Math.cos(Math.PI/12);

var angBA:Number=Math.atan2(by-ay,bx-ax);

var cx:Number=ax+ac*Math.cos(angBA-Math.PI/12); var cy:Number=ay+ac*Math.sin(angBA-Math.PI/12);

var angBC:Number=Math.atan2(by-cy,bx-cx); var ce=1/12*ab;

var ex:Number=cx+ce*Math.cos(angBC-Math.PI/12); var ey:Number=cy+ce*Math.sin(angBC-Math.PI/12);

var dx:Number=cx+ce*Math.cos(angBC-Math.PI/12-Math.PI); var dy:Number=cy+ce*Math.sin(angBC-Math.PI/12-Math.PI); var ef=ce/Math.cos(Math.PI*5/12);

var angDE:Number=Math.atan2(ey-dy,ex-dx); var fx=dx+ef*Math.cos(angDE-Math.PI*5/12); var fy=dy+ef*Math.sin(angDE-Math.PI*5/12); longquxian(ax,ay,cx,cy,n+1);

longquxian(ex,ey,dx,dy,n+1);//注意ED的顺序是先E后D其他四条都是先左后右 longquxian(dx,dy,fx,fy,n+1); longquxian(fx,fy,ex,ey,n+1); longquxian(cx,cy,bx,by,n+1); } }

addEventListener(Event.ENTER_FRAME ,frame); addbtn.addEventListener(MouseEvent.CLICK ,clf); subbtn.addEventListener(MouseEvent.CLICK ,clf); function clf(e) {

if (e.target.name==\"addbtn\") { N++; }

if (e.target.name==\"subbtn\") { N>0?N--:0; }

addEventListener(Event.ENTER_FRAME ,frame);

//不直接调用initf函数而添加帧频函数调用的好处是可以时刻改变颜色达到绚丽的效果 }

function frame(e) { graphics.clear();

longquxian(50,400,550,400,0); }

实例82 分形的研究-----皇冠帽二

var N:Number=3;// var len:Number;

var bmp:BitmapData=new BitmapData(600,500,false,0x000000);//创建一个黑色不透明的位图，

var bmt:Bitmap =new Bitmap(bmp) addChild(bmt)

function setpixel(ax,ay,bx,by) {

bmp.setPixel (ax,ay,0xffffff*Math.random ())//利用位图点的颜色设置来达到效果 bmp.setPixel (bx,by,0xffffff*Math.random ()) }

//======

function huangguanmao(ax:Number ,ay:Number ,bx:Number ,by:Number,n ) { if (n>N) {

setpixel(ax,ay,bx,by); } else {

var ab=Point.distance(new Point(ax,ay),new Point(bx,by)); var ac=ab/2/Math.cos(Math.PI/12);

var angBA:Number=Math.atan2(by-ay,bx-ax);

var cx:Number=ax+ac*Math.cos(angBA-Math.PI/12); var cy:Number=ay+ac*Math.sin(angBA-Math.PI/12); var angBC:Number=Math.atan2(by-cy,bx-cx); var ce=1/12*ab;

var ex:Number=cx+ce*Math.cos(angBC-Math.PI/12); var ey:Number=cy+ce*Math.sin(angBC-Math.PI/12);

var dx:Number=cx+ce*Math.cos(angBC-Math.PI/12-Math.PI); var dy:Number=cy+ce*Math.sin(angBC-Math.PI/12-Math.PI); var ef=ce/Math.cos(Math.PI*5/12);

var angDE:Number=Math.atan2(ey-dy,ex-dx); var fx=dx+ef*Math.cos(angDE-Math.PI*5/12); var fy=dy+ef*Math.sin(angDE-Math.PI*5/12); huangguanmao(ax,ay,cx,cy,n+1);

huangguanmao(ex,ey,dx,dy,n+1);//注意ED的顺序是先E后D其他四条都是先左后右 huangguanmao(dx,dy,fx,fy,n+1); huangguanmao(fx,fy,ex,ey,n+1); huangguanmao(cx,cy,bx,by,n+1); } }

addEventListener(Event.ENTER_FRAME ,frame); addbtn.addEventListener(MouseEvent.CLICK ,clf); subbtn.addEventListener(MouseEvent.CLICK ,clf); function clf(e) {

if (e.target.name==\"addbtn\") { N++; }

if (e.target.name==\"subbtn\") { N>0?N--:0; }

addEventListener(Event.ENTER_FRAME ,frame);

//不直接调用initf函数而添加帧频函数调用的好处是可以时刻改变颜色达到绚丽的效果 }

function frame(e) {

bmp.fillRect (bmp.rect ,0x000000)//因为这种方法不是画线所以不能用graphics。clear（）

//因此把位图重新填充为黑色来达到刷新的效果 huangguanmao(50,400,550,400,0); }

实例83 分形的研究-----勾股树

function square(x1:Number ,y1:Number ,x2:Number ,y2:Number ) {//x1，y1是正方形左下角的坐标，x2，y2是正方形的右下角的坐标 graphics.lineStyle(2,0xffffff*Math.random ()); graphics.beginFill(0xffffff*Math.random ()); graphics.moveTo(x1,y1);//从左下角开始画线 graphics.lineTo(x2,y2);//右下角

var dis:Number =Math.sqrt ((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));//正方形的边长

var ang1:Number=Math.atan2(y1-y2,x1-x2);//左下角的点相对于右下角的点的角度 graphics.lineTo(x2+dis*Math.cos (ang1+Math.PI /2),y2+dis*Math.sin (ang1+Math.PI /2));//右上角

//右上角的点的坐标计算：以右下角点即x2，y2为圆心，把左下角的点即x1，y1顺时针旋转九十度即可得到右上角

//所以用圆的参数方程求坐标的角度为左下角的点相对于右下角的角度再加上九十度

var ang2:Number=Math.atan2(y2-y1,x2-x1); //右下角的点相对于左下角的点的计算

graphics.lineTo(x1+dis*Math.cos (ang2-Math.PI /2),y1+dis*Math.sin (ang2-Math.PI /2));//左上角

//左上角的点的计算：以左下角的点为圆心，把右下角的点逆时针旋转九十度所以用ang2减去九十度

graphics.lineTo(x1,y1);//左下角 graphics.endFill(); }

var N:int=9;

function gougushu(oldx:Number ,oldy:Number ,newx:Number ,newy:Number ,n) {//形参数分别为：old坐标最大大正方形的左下角的点坐标，new是右下角的坐标 if (nsquare(oldx,oldy,newx,newy);//先画一个最大的正方形 var Ang1:Number=Math.atan2(oldy-newy,oldx-newx);

//新的正方形行左下角的点相对于新的正方形的右下角的角度 var Ang2:Number=Math.atan2(newy-oldy,newx-oldx);

//新的正方形右下角的点相对于新的正方形左下角的点的角度注意这两个角不是相同的的两个角度因为这里的角度有方向

var len:Number =Math.sqrt ((newx-oldx)*(newx-oldx)+(newy-oldy)*(newy-oldy));//求新的正方形的边长

oldx=oldx+len*Math.cos(Ang2-Math.PI/2);//新的正方形左下角的顶点坐标其实是原

来大的正方形的左上角的顶点

newx=newx+len*Math.cos(Ang1+Math.PI/2);//新的正方形的右下角的点其实是原来正方形的右上角的顶点

oldy=oldy+len*Math.sin(Ang2-Math.PI/2);//这是重新定义行的正方形中的这两个点坐标作为形参中的oldx和oldy

newy=newy+len*Math.sin(Ang1+Math.PI/2);

var r:Number=Point.distance(new Point(oldx,oldy),new Point(newx,newy))/2;//大的正方形边长除以2即是以左下角和右下角连个点为边做直径半圆的半径 var zdx:Number =(oldx+newx)/2;//求出该边中点坐标 var zdy:Number =(oldy+newy)/2;

var ang:Number=- Math.PI*Math.random();//因为直角三角形的直角顶点是半圆上任意一点

var xx:Number=zdx+r*Math.cos(ang+Ang2);//直角顶点的坐标用的是圆的参数方程 var yy:Number=zdy+r*Math.sin(ang+Ang2); square(oldx,oldy,xx,yy);//画左边的三角形，这时参数仍然是正方形的左下角的点和右下角的点

//注意它的右下角的点是直角三角形的直角顶点即

square(xx,yy,newx,newy);//画右边的三角形，这时正方形的左下角的点是直角顶点，右下角的点newx和newy注意此时的 //这个点已经上面重新定义了 //len=r;//此时的正方形边长为r gougushu(oldx,oldy,xx,yy,n+1); gougushu(xx,yy,newx,newy,n+1); } }

gougushu(100,400,200,400,0);

stage.addEventListener(MouseEvent.CLICK ,clickf); function clickf(e) { graphics.clear();

gougushu(100,400,200,400,0); }

addbtn.addEventListener(MouseEvent.CLICK ,f1); function f1(e) { if (N<10) { N++; } }

subbtn.addEventListener(MouseEvent.CLICK ,f2); function f2(e) { if (N>0) { N--; } }

实例84分形的研究----龙曲线

var N:Number=10;

function longquxian(ax:Number ,ay:Number ,bx:Number ,by:Number,n ) { if (n>N) {

graphics.lineStyle(2,0xffffff*Math.random ()); graphics.moveTo(ax,ay); graphics.lineTo(bx,by);

} else {//龙曲线是以一条线段为斜边得到等腰三角形的两条直角边， //再分别以两条直角边为斜边在得到等腰直角三角形，因此主要是求等腰直角三角形顶点的坐标

var ab=Point.distance(new Point(ax,ay),new Point(bx,by)); var ac=ab*Math.sqrt(2)/2;

var angBA:Number=Math.atan2(by-ay,bx-ax);

var cx:Number=ax+ac*Math.cos(angBA-Math.PI/4); var cy:Number=ay+ac*Math.sin(angBA-Math.PI/4); longquxian(ax,ay,cx,cy,n+1); longquxian(bx,by,cx,cy,n+1);

//注意利用起点的顺序不同达到了两个等腰三角形顶点的位置不同，如图引导层，如果a是起点，c是结束点

//那么因为上面等腰直角三角形的顶点是按照逆时针旋转四十五度求的 所以，所以左边的等腰三角形顶点d点就是在上面，

//而把b点做起点c点做结束点，右边的等腰直角三角形的顶点在下面 //反之若先c后b则得到龙曲线2 } }

addEventListener(Event.ENTER_FRAME ,frame); addbtn.addEventListener(MouseEvent.CLICK ,clf); subbtn.addEventListener(MouseEvent.CLICK ,clf); function clf(e) {

if (e.target.name==\"addbtn\") { N++; }

if (e.target.name==\"subbtn\") { N>0?N--:0; }

addEventListener(Event.ENTER_FRAME ,frame);

//不直接调用initf函数而添加帧频函数调用的好处是可以时刻改变颜色达到绚丽的效果

}

function frame(e) { graphics.clear();

longquxian(150,400,500,400,0); }

实例85 分形的研究----龙曲线2

var N:Number=10; var len:Number;

function longquxian(ax:Number ,ay:Number ,bx:Number ,by:Number,n ) { if (n>N) {

graphics.lineStyle(2,0xffffff*Math.random ()); graphics.moveTo(ax,ay); graphics.lineTo(bx,by); } else {

var ab=Point.distance(new Point(ax,ay),new Point(bx,by)); var ac=2*ab*Math.sqrt(5)/5;

var angBA:Number=Math.atan2(by-ay,bx-ax); var ang0:Number=Math.acos(ac/ab);

var cx:Number=ax+ac*Math.cos(angBA-ang0); var cy:Number=ay+ac*Math.sin(angBA-ang0); longquxian(ax,ay,cx,cy,n+1); longquxian(bx,by,cx,cy,n+1);

//注意利用起点的顺序不同达到了两个等腰三角形顶点的位置不同，如图引导层，如果a是起点，c是结束点

//那么因为上面等腰直角三角形的顶点是按照逆时针旋转四十五度求的所以，所以左边的等腰三角形顶点d点就是在上面，

//而把b点做起点c点做结束点，右边的等腰直角三角形的顶点在下面 //反之若先c后b则得到龙曲线2 } }

addEventListener(Event.ENTER_FRAME ,frame); addbtn.addEventListener(MouseEvent.CLICK ,clf); subbtn.addEventListener(MouseEvent.CLICK ,clf); function clf(e) {

if (e.target.name==\"addbtn\") { N++; }

if (e.target.name==\"subbtn\") { N>0?N--:0; }

addEventListener(Event.ENTER_FRAME ,frame);

//不直接调用initf函数而添加帧频函数调用的好处是可以时刻改变颜色达到绚丽的效果

}

function frame(e) { graphics.clear();

longquxian(150,400,500,400,0); }

实例86 分形的研究---龙曲线三

var N:Number=10;// var len:Number;

function line(ax,ay,bx,by) {

graphics.lineStyle(2,0xffffff*Math.random ()); graphics.moveTo(ax,ay); graphics.lineTo(bx,by); }

//======

function longquxian(ax:Number ,ay:Number ,bx:Number ,by:Number,n ) { if (n>N) {

line(ax,ay,bx,by); } else {

var ab=Point.distance(new Point(ax,ay),new Point(bx,by)); var ac=ab*Math.sqrt(2)/2;

var angBA:Number=Math.atan2(by-ay,bx-ax);

var cx:Number=ax+ac*Math.cos(angBA-Math.PI/4); var cy:Number=ay+ac*Math.sin(angBA-Math.PI/4); longquxian(ax,ay,cx,cy,n+1); longquxian(cx,cy,bx,by,n+1); } }

addEventListener(Event.ENTER_FRAME ,frame); addbtn.addEventListener(MouseEvent.CLICK ,clf); subbtn.addEventListener(MouseEvent.CLICK ,clf); function clf(e) {

if (e.target.name==\"addbtn\") { N++; }

if (e.target.name==\"subbtn\") { N>0?N--:0; }

addEventListener(Event.ENTER_FRAME ,frame);

//不直接调用initf函数而添加帧频函数调用的好处是可以时刻改变颜色达到绚丽的效果 }

function frame(e) { graphics.clear();

longquxian(100,400,450,400,0); }

实例87 分形的研究---任意梦幻正多边形

function duobianxing(N:int,R:Number,X:Number,Y:Number ,ang:Number ) { //参数为正多边形的边数，半径和中心坐标 多边形起点的倾斜角 graphics.lineStyle(2,0xffffff*Math.random ()); graphics.beginFill(0xffffff*Math.random ());

graphics.moveTo(X+R*Math.cos(ang),Y+R*Math.sin(ang)); for (var i:int=0; ivar N:int=6;//初始迭代次数 var num=3;//正多边形的边数

var rr:Number=300;//初始最大正多边形的半 function diedai(num,r,zx,zy,ang,Ang,n) {//

if (nvar ang0:Number=Ang;//里边多边形的起点逆时针旋转过的角度

var newr=r*Math.cos(Math.PI/num)/Math.cos(Math.PI/num-ang0);//新的五边形的半径计算即引导层中的oa撇

duobianxing(num,newr,zx,zy,ang+ang0);//画五边形参数边数不变，半径是 新半径，中心坐标不变，起始点的角度 //在原来的基础上ang旋转过一个角度ang0

diedai(num,newr,zx,zy,ang+ang0,Ang,n+1);//迭代时，边数和中心坐标不变，改变半径，和起始点角度

//迭代参数，新的多边形的旋转过的角度不变Ang } }

addEventListener(Event.ENTER_FRAME ,frame); addbtn.addEventListener(MouseEvent.CLICK ,clf); subbtn.addEventListener(MouseEvent.CLICK ,clf); addnum.addEventListener(MouseEvent.CLICK ,clf); subnum.addEventListener(MouseEvent.CLICK ,clf); function clf(e) {

if (e.target.name==\"addbtn\") { N<13?N++:0;//迭代次数小于5 }

if (e.target.name==\"subbtn\") { N>0?N--:0; }

if (e.target.name==\"addnum\") { num<10?num++:0;// }

if (e.target.name==\"subnum\") { num>0?num--:0; }

addEventListener(Event.ENTER_FRAME ,frame);

//不直接调用initf函数而添加帧频函数调用的好处是可以时刻改变颜色达到绚丽的效果 }

var startang=0;//

function frame(e) {//=外边不动的多边形 graphics.clear();

duobianxing(num,rr,300,300,0);

startang+=Math.PI/180;//逐渐增加一度实现旋转的效果 diedai(num,rr,300,300,0, startang,0);

if (startang>=Math.PI*2/num) {//如果增加到一个中心角的时候重新归零 startang=0; } }

实例88 分形的研究---任意多角星1

//==========利用正多边形画正多角星，只有该函数稍微变化其他和正多边形迭代代码完全一样

function duobianxing(N:int,R:Number,X:Number,Y:Number ,ang:Number ) { //参数为正多边形的边数，半径和中心坐标 多边形起点的倾斜角 graphics.lineStyle(2,0xffffff*Math.random ()); graphics.beginFill(0xffffff*Math.random ());

graphics.moveTo(X+R*Math.cos(ang),Y+R*Math.sin(ang));//起点 var r:Number;

for (var i:int=0; i<2*N; i++) {//从起点按顺时针一次画出因为n角星有2n个顶点 i%2==1?r=R:r=R/2;//外边的n个顶点半径为R，里面的n个顶点半径为R/2

var xx:Number=X+r*Math.cos((i+1)*Math.PI*2/N/2+ang);//当=0时实际上是画的第二个点，所以当i=2n-1时候回到了起点形成封闭图形 var yy:Number=Y+r*Math.sin((i+1)*Math.PI*2/N/2+ang); graphics.lineTo(xx,yy); } }

var N:int=2;//初始迭代次数

var num=6;//正多边形的边数

var rr:Number=100;//初始最大正多边形的半径 var scale:Number=0.4;//正多边形的边长缩小比例 //============其中之一的迭代过程函数

function diedai(m:int,r:Number,x0:Number ,y0:Number,ang,n:int) { //ang是较大的多边形的起点倾斜角 if (n//再画周围的m-1个较小的正多边形

var newr:Number=r*scale;//计算这些小多边形的边长

for (var j:int=0; j//计算它们的中心位置，以较大的中心为圆心，以r+scaler为半径的圆周上 var newx:Number=x0+(1+scale)*r*Math.cos(ang-j*Math.PI*2/m); var newy:Number=y0+(1+scale)*r*Math.sin(ang-j*Math.PI*2/m);

//因为每个小正多边形的中心和大正多边形的中心以及它们连接的顶点都在一条直线上，

//因此连接点相对于大正多边形的倾斜角与连接点相对于每个小正多边形的倾斜角是互补的

//所以用180减去每个连接点的倾斜角ang-j*Math.PI*2/m则是连接点相对于小正方形的倾斜角然后把这个角度作为起始角，画出小正多边形

duobianxing(m,newr,newx,newy,Math.PI-(ang-j*Math.PI*2/m));

var ang0:Number=Math.atan2(y0-newy,x0-newx);//重新计算较大正方形的中心相对于每个小正多边形中心的倾斜角

diedai(m,newr,newx,newy,ang0-Math.PI*2/m,n+1);

//较小的正多边形的中心坐标和半径又作为下次迭代较大的正多边形的中心和半径，注意此时要把ang0逆时针旋转一个中心角

//作为新的较大的正多边形的起始顶点的倾斜角， } } }

//==============循环迭代生成效果 function initf() {

duobianxing(num,rr,300,300,0);//先画中间的大正多边形//因为场景是600×600中心是300,300

for (var k:int =0; kvar xxx:Number=300+(1+scale)*rr*Math.cos(k*Math.PI*2/num);//大半径是100所100+38=150

var yyy:Number=300+(1+scale)*rr*Math.sin(k*Math.PI*2/num);//得到四个小正方形的顶点

var ang:Number=Math.atan2(300-yyy,300-xxx);

//计算中间的最大正多边形相对于每个小正多边形的中心的倾斜角，因为这两个中心和它们的连接顶点 //在一条直线上，因次也是每个连接顶点相对于每个小正多边形的倾斜角所以把这个

倾斜角逆时针旋转一个中心角度

//作为迭代函数中较大正多边形的起始顶点倾斜角

diedai(num,scale*rr,xxx,yyy,ang-Math.PI*2/num,0);//分别作为迭代参数调用迭代函数 } }

addEventListener(Event.ENTER_FRAME ,frame); addbtn.addEventListener(MouseEvent.CLICK ,clf); subbtn.addEventListener(MouseEvent.CLICK ,clf); addnum.addEventListener(MouseEvent.CLICK ,clf); subnum.addEventListener(MouseEvent.CLICK ,clf); function clf(e) {

if (e.target.name==\"addbtn\") { N<8?N++:0;//迭代次数小于5 }

if (e.target.name==\"subbtn\") { N>0?N--:0; }

if (e.target.name==\"addnum\") { num<10?num++:0;//迭代次数小于5 }

if (e.target.name==\"subnum\") { num>0?num--:0; }

addEventListener(Event.ENTER_FRAME ,frame);

//不直接调用initf函数而添加帧频函数调用的好处是可以时刻改变颜色达到绚丽的效果 }

function frame(e) { graphics.clear(); initf(); }

实例89 分形的研究---任意多角星2

function duobianxing(N:int,R:Number,X:Number,Y:Number ,ang:Number ) { //参数为正多边形的边数，半径和中心坐标 多边形起点的倾斜角 graphics.lineStyle(2,0xffffff*Math.random ()); graphics.beginFill(0xffffff*Math.random ()); for (var i:int=0; ivar xx:Number=X+R*Math.cos(i*Math.PI*2/N+ang);//当=0时实际上是画的第二个点，所以当i=2n-1时候回到了起点形成封闭图形

var yy:Number=Y+R*Math.sin(i*Math.PI*2/N+ang); graphics.moveTo(xx,yy); var x1:Number; var y1:Number;

if (N%2==1) {//当奇数边正多边形则让第i个顶点和第i+（n-3）/2个顶点连线 x1=X+R*Math.cos((i+1+(N-3)/2)*Math.PI*2/N+ang); y1=Y+R*Math.sin((i+1+(N-3)/2)*Math.PI*2/N+ang); }

if (N%2==0) {//当偶数边时则第i个顶点和第i+(n-4)/2个顶点连线 x1=X+R*Math.cos((i+1+(N-4)/2)*Math.PI*2/N+ang); y1=Y+R*Math.sin((i+1+(N-4)/2)*Math.PI*2/N+ang); }

graphics.lineTo(x1,y1); } }

var N:int=2;//初始迭代次数 var num=5;//正多边形的边数

var rr:Number=150;//初始最大正多边形的半径 var scale:Number=0.3;//正多边形的边长缩小比例 //============其中之一的迭代过程函数

function diedai(m:int,r:Number,x0:Number ,y0:Number,ang,n:int) { //ang是较大的多边形的起点倾斜角 if (n//再画周围的m-1个较小的正多边形

var newr:Number=r*scale;//计算这些小多边形的边长

for (var j:int=0; j//计算它们的中心位置，以较大的中心为圆心，以r+scaler为半径的圆周上 var newx:Number=x0+(1+scale)*r*Math.cos(ang-j*Math.PI*2/m); var newy:Number=y0+(1+scale)*r*Math.sin(ang-j*Math.PI*2/m);

//因为每个小正多边形的中心和大正多边形的中心以及它们连接的顶点都在一条直线上，

//因此连接点相对于大正多边形的倾斜角与连接点相对于每个小正多边形的倾斜角是互补的

//所以用180减去每个连接点的倾斜角ang-j*Math.PI*2/m则是连接点相对于小正方形的倾斜角然后把这个角度作为起始角，画出小正多边形 duobianxing(m,newr,newx,newy,Math.PI-(ang-j*Math.PI*2/m));

var ang0:Number=Math.atan2(y0-newy,x0-newx);//重新计算较大正方形的中心相对于每个小正多边形中心的倾斜角

diedai(m,newr,newx,newy,ang0-Math.PI*2/m,n+1);

//较小的正多边形的中心坐标和半径又作为下次迭代较大的正多边形的中心和半径，注意此时要把ang0逆时针旋转一个中心角

//作为新的较大的正多边形的起始顶点的倾斜角， } } }

//==============循环迭代生成效果

function initf() {

duobianxing(num,rr,300,300,0);//先画中间的大正多边形//因为场景是600×600中心是300,300

for (var k:int =0; kvar xxx:Number=300+(1+scale)*rr*Math.cos(k*Math.PI*2/num);//大半径是100所100+38=150

var yyy:Number=300+(1+scale)*rr*Math.sin(k*Math.PI*2/num);//得到四个小正方形的顶点

var ang:Number=Math.atan2(300-yyy,300-xxx);

//计算中间的最大正多边形相对于每个小正多边形的中心的倾斜角，因为这两个中心和它们的连接顶点 //在一条直线上，因次也是每个连接顶点相对于每个小正多边形的倾斜角所以把这个倾斜角逆时针旋转一个中心角度

//作为迭代函数中较大正多边形的起始顶点倾斜角

diedai(num,scale*rr,xxx,yyy,ang-Math.PI*2/num,0);//分别作为迭代参数调用迭代函数 } }

//==================

addEventListener(Event.ENTER_FRAME ,frame); addbtn.addEventListener(MouseEvent.CLICK ,clf); subbtn.addEventListener(MouseEvent.CLICK ,clf); addnum.addEventListener(MouseEvent.CLICK ,clf); subnum.addEventListener(MouseEvent.CLICK ,clf); function clf(e) {

if (e.target.name==\"addbtn\") { N<8?N++:0;//迭代次数小于5 }

if (e.target.name==\"subbtn\") { N>0?N--:0; }

if (e.target.name==\"addnum\") { num<10?num++:0;//迭代次数小于5 }

if (e.target.name==\"subnum\") { num>0?num--:0; }

addEventListener(Event.ENTER_FRAME ,frame);

//不直接调用initf函数而添加帧频函数调用的好处是可以时刻改变颜色达到绚丽的效果 }

function frame(e) { graphics.clear(); initf();

}

实例90 分形的研究---任意多角星3

function duobianxing(N:int,R:Number,X:Number,Y:Number ,ang:Number ) { //参数为正多边形的边数，半径和中心坐标 多边形起点的倾斜角 graphics.lineStyle(2,0xffffff*Math.random ());

for (var i:int=0; ivar xx:Number=X+R*Math.cos(i*Math.PI*2/N+ang);//当=0时实际上是画的第二个点，所以当i=2n-1时候回到了起点形成封闭图形

var yy:Number=Y+R*Math.sin(i*Math.PI*2/N+ang); graphics.moveTo(xx,yy); var x1:Number; var y1:Number;

if (N%2==1) {//当奇数边正多边形则让第i个顶点和第i+（n-3）/2个顶点连线 x1=X+R*Math.cos((i+1+(N-3)/2)*Math.PI*2/N+ang); y1=Y+R*Math.sin((i+1+(N-3)/2)*Math.PI*2/N+ang); }

if (N%2==0) {//当偶数边时则第i个顶点和第i+(n-4)/2个顶点连线 x1=X+R*Math.cos((i+1+(N-4)/2)*Math.PI*2/N+ang); y1=Y+R*Math.sin((i+1+(N-4)/2)*Math.PI*2/N+ang); }

graphics.lineTo(x1,y1); }

//========通过循环得到星形里面的小的正多边形

var r:Number=R*Math.cos(int((N-1)/2)*2*Math.PI/N/2)/Math.cos(Math.PI/N);//小正多边形的半径计算即引导层中的0A撇的值

var ang0:Number =int((N-1)/2)*2*Math.PI/N/2-Math.PI /N;

graphics.moveTo(X+r*Math.cos(ang+ang0),Y+r*Math.sin(ang+ang0));

//;注意这个正多边形的起点要在星形起点的基础上顺时针或者逆时针旋转ang0 graphics.lineStyle(2,0xffffff);

graphics.beginFill(0xffffff*Math.random ()); for (i=0; ivar x2:Number=X+r*Math.cos(ang+ang0+(i+1)*Math.PI*2/N);//当=0时实际上是画的第二个点，所以当i=2n-1时候回到了起点形成封闭图形 var y2:Number=Y+r*Math.sin(ang+ang0+(i+1)*Math.PI*2/N); graphics.lineTo(x2,y2); }

graphics.endFill(); }

var N:int=2;//初始迭代次数 var num=5;//正多边形的边数

var rr:Number=150;//初始最大正多边形的半径 var scale:Number=0.3;//正多边形的边长缩小比例 //============其中之一的迭代过程函数

function diedai(m:int,r:Number,x0:Number ,y0:Number,ang,n:int) { //ang是较大的多边形的起点倾斜角 if (n//再画周围的m-1个较小的正多边形

var newr:Number=r*scale;//计算这些小多边形的边长

for (var j:int=0; j//计算它们的中心位置，以较大的中心为圆心，以r+scaler为半径的圆周上 var newx:Number=x0+(1+scale)*r*Math.cos(ang-j*Math.PI*2/m); var newy:Number=y0+(1+scale)*r*Math.sin(ang-j*Math.PI*2/m);

//因为每个小正多边形的中心和大正多边形的中心以及它们连接的顶点都在一条直线上，

//因此连接点相对于大正多边形的倾斜角与连接点相对于每个小正多边形的倾斜角是互补的

//所以用180减去每个连接点的倾斜角ang-j*Math.PI*2/m则是连接点相对于小正方形的倾斜角然后把这个角度作为起始角，画出小正多边形 duobianxing(m,newr,newx,newy,Math.PI-(ang-j*Math.PI*2/m));

var ang0:Number=Math.atan2(y0-newy,x0-newx);//重新计算较大正方形的中心相对于每个小正多边形中心的倾斜角

diedai(m,newr,newx,newy,ang0-Math.PI*2/m,n+1);

//较小的正多边形的中心坐标和半径又作为下次迭代较大的正多边形的中心和半径，注意此时要把ang0逆时针旋转一个中心角

//作为新的较大的正多边形的起始顶点的倾斜角， } } }

//==============循环迭代生成效果 function initf() {

duobianxing(num,rr,300,300,0);//先画中间的大正多边形//因为场景是600×600中心是300,300

for (var k:int =0; kvar xxx:Number=300+(1+scale)*rr*Math.cos(k*Math.PI*2/num);//大半径是100所100+38=150

var yyy:Number=300+(1+scale)*rr*Math.sin(k*Math.PI*2/num);//得到四个小正方形的顶点

var ang:Number=Math.atan2(300-yyy,300-xxx);

//计算中间的最大正多边形相对于每个小正多边形的中心的倾斜角，因为这两个中心和它们的连接顶点 //在一条直线上，因次也是每个连接顶点相对于每个小正多边形的倾斜角所以把这个倾斜角逆时针旋转一个中心角度

//作为迭代函数中较大正多边形的起始顶点倾斜角

diedai(num,scale*rr,xxx,yyy,ang-Math.PI*2/num,0);//分别作为迭代参数调用迭代函数 }

}//==================

addEventListener(Event.ENTER_FRAME ,frame); addbtn.addEventListener(MouseEvent.CLICK ,clf); subbtn.addEventListener(MouseEvent.CLICK ,clf); addnum.addEventListener(MouseEvent.CLICK ,clf); subnum.addEventListener(MouseEvent.CLICK ,clf); function clf(e) {

if (e.target.name==\"addbtn\") { N<8?N++:0;//迭代次数小于5 }

if (e.target.name==\"subbtn\") { N>0?N--:0; }

if (e.target.name==\"addnum\") { num<10?num++:0;//迭代次数小于5 }

if (e.target.name==\"subnum\") { num>0?num--:0; }

addEventListener(Event.ENTER_FRAME ,frame);

//不直接调用initf函数而添加帧频函数调用的好处是可以时刻改变颜色达到绚丽的效果 }

function frame(e) { graphics.clear(); initf();}

实例91 分形的研究---中点三角形

//=======画三角形

var color:uint=0xffffff*Math.random(); var mc:MovieClip =new MovieClip() addChild(mc)

mc.filters =[new BevelFilter(),new GlowFilter()]

function sanjiaoxing(x1:Number,y1:Number,x2:Number ,y2:Number ) {//三角形左下角的坐标，和三角形右下角的坐标 mc.graphics.lineStyle(2,color);

mc.graphics.moveTo(x1,y1);//先画三角形下边的一条线 mc.graphics.beginFill(color); mc.graphics.lineTo(x2,y2);

//计算三角形的边长可以用两点间的距离公式，也可以用点的距离属性 var len:Number=Point.distance(new Point(x1,y1),new Point(x2,y2));

var ang:Number=Math.atan2(y2-y1,x2-x1);//计算右下角的点相对于左下角的倾斜角 var x3:Number=x1+len*Math.cos(ang-1/3*Math.PI); var y3:Number=y1+len*Math.sin(ang-1/3*Math.PI);

mc.graphics.lineTo(x3,y3); mc.graphics.lineTo(x1,y1); mc.graphics.endFill(); }

var N:int=4;

function diedai(xx1:Number ,yy1:Number ,xx2:Number ,yy2:Number ,n) { //参数分别为三角形左下角点坐标，右下角坐标，迭代次数 if (n//sanjiaoxing(xx1,yy1,xx2,yy2);//先画一个最大的三角形 //计算两个顶点的倾斜角

var Ang:Number=Math.atan2(yy2-yy1,xx2-xx1);

var Len:Number=Point.distance(new Point(xx1,yy1),new Point(xx2,yy2)); //计算第三个顶点的坐标

var xx3:Number=xx1+Len*Math.cos(Ang-1/3*Math.PI);//第三个定点相对于第一个顶点来说是逆时针旋转了六十度

var yy3:Number=yy1+Len*Math.sin(Ang-1/3*Math.PI); //计算三个中点的坐标

var middlex1:Number =(xx1+xx2)/2;//第一个中点 var middley1:Number =(yy1+yy2)/2;

var middlex2:Number =(xx1+xx3)/2;//第二个中点 var middley2:Number =(yy1+yy3)/2;

var middlex3:Number =(xx3+xx2)/2;//第三个中点 var middley3:Number =(yy3+yy2)/2;

color=0xffffff*Math.random();//左下角的三角形颜色 sanjiaoxing(xx1,yy1,middlex1,middley1);//左下角三角形 color=0xffffff*Math.random();//右下角颜色

sanjiaoxing(middlex1,middley1,xx2,yy2);//右下角三角形 color=0xffffff*Math.random();//上面颜色

sanjiaoxing(middlex2,middley2,middlex3,middley3);//上面三角形 color=0x000000;//中间颜色

sanjiaoxing(middlex1,middley1,middlex3,middley3);//中间三角形用黑色填充造成中空的假象

diedai(xx1 ,yy1 , middlex1 ,middley1 ,n+1);//把三个三角形分别进行迭代 diedai(middlex1 ,middley1 ,xx2 ,yy2, n+1);

diedai(middlex2 ,middley2 ,middlex3 ,middley3, n+1); } }

addEventListener(Event.ENTER_FRAME ,f); function f(e) {

mc.graphics.clear();

color=0xffffff*Math.random(); diedai(50,400,450,400,0); }

addbtn.addEventListener(MouseEvent.CLICK ,f1);

function f1(e) { if (N<10) { N++; } }

subbtn.addEventListener(MouseEvent.CLICK ,f2); function f2(e) { if (N>0) { N--; } }

实例 92分形的研究---雪花的迭代生成

//=========第二中方法是利用参数n设置迭代次数 //场景中有个addbtn和subbtn按钮和一个txt文本框 txt.autoSize=\"left\";

var scy:String=\"F-F++F-F\";//定义生成法则

var axiom:String=\"F++F++F\";//初始定义一个生成元

//如果改成F++F++F则可以变成初始元为三角形迭代结果为雪花 var n:int=4;//定义迭代次数

var ang:Number=0;//初始旋转角度

var offsetA:Number=60;//角度偏移的角度 var len:Number=450;//起点到终点的长度

var d:Number=len*Math.pow(4/3,n)/Math.pow(4,n);//每一段的长度 //======定义迭代生成过程函数 function makeStr(n) {//

for (var m:int=0; mvar tempStr:String=\"\";//声明一个临时字符串用来装生成的迭代n次地字符串 var j:int=0;//用来查找字符串中的第j个字符 while (jvar s:String=axiom.substr(j,1);

if (s==\"F\") {//如果查找到的是F则让临时字符串添加一个生成元 tempStr+=scy ;

} else {//如果查找到是+或者减号那么直接添加到临时字符串 tempStr+=s; } j++; }

axiom=tempStr;//每次迭代后把临时字符串重新赋给生成过程字符串里 } }

function drawkoch(x0:Number,y0:Number ) {

graphics.lineStyle(3,0x000000); graphics.moveTo(x0,y0); var x1:Number=0; var y1:Number=0; var i:int=0;

while (ivar s:String=axiom.substr(i,1);//截取 switch (s) {

case \"F\" ://如果F就划线

x1=x0+d*Math.cos(ang*Math.PI/180); y1=y0+d*Math.sin(ang*Math.PI/180); graphics.lineTo(x1,y1); x0=x1; y0=y1; break;

case \"+\" ://如果＋就顺时针旋转60 ang+=offsetA; break;

case \"-\" ://如果是减号就逆时针旋转60 ang-=offsetA; break; } i++; } }

addEventListener(Event.ENTER_FRAME ,ff); //先调用一次帧频函数

addbtn.addEventListener(MouseEvent.CLICK ,f); subbtn.addEventListener(MouseEvent.CLICK ,f); function f(e) {

if (e.target.name==\"addbtn\") { n<=4?n++:0; } else { n>0?n--:0; }

addEventListener(Event.ENTER_FRAME ,ff);//再调用帧频函数 }

function ff(e) {

graphics.clear();//如果没有这个帧频函数，而把函数体内的直接写到点击函数中 //也可以，只是颜色不能时刻改变，只有点击才改变迭代次数和颜色而写到这个帧频函数中则

//可以在边数一定的情况下颜色不停地改变

graphics.beginFill(0xffffff*Math.random ()); axiom=\"F++F++F\";

ang=0;

d=len*Math.pow(4/3,n)/Math.pow(4,n); makeStr(n);

drawkoch(50,200); txt.text=axiom; }

实例93 分形的研究---涡旋曲线的生成

var startx:Number=150; var starty:Number=350; var startlen:Number=100; var startang:Number=0; var startsize:Number=5; var color:uint;

function woxuanquxian(xx:Number ,yy:Number ,len:Number ,ang:Number ,size:Number ) {

if (len>10) {

color=0xffffff*Math.random(); graphics.lineStyle(size,color); graphics.moveTo(xx,yy);

var endx:Number=xx+Math.cos(ang)*len; var endy:Number=yy+Math.sin(ang)*len; graphics.lineTo(endx,endy);

woxuanquxian(endx,endy,len*.95,ang-Math.PI/4,size-.1); } }

woxuanquxian(startx,starty,startlen,startang,startsize); stage.addEventListener(MouseEvent.CLICK ,clf); function clf(e) { graphics.clear();

startlen=200*Math.random()+100;

woxuanquxian(startx,starty,startlen,startang,startsize); }

涡旋曲线的展开与收缩

var startx:Number=50;//开始点初坐标 var starty:Number=550;

var startlen:Number=100;//第一条线段初始长度 var startang:Number=0;//第一条线段初始倾斜角 var startsize:Number=5;//第一条线段初始粗细 var color:uint;

var ang0=Math.PI/4;//初始逆时针旋转角

function woxuanquxian(xx:Number ,yy:Number ,len:Number ,ang:Number ,size:Number ) {

if (len>10) {

color=0xffffff*Math.random(); graphics.lineStyle(size,color); graphics.moveTo(xx,yy);

var endx:Number=xx+Math.cos(ang)*len; var endy:Number=yy+Math.sin(ang)*len; graphics.lineTo(endx,endy);

woxuanquxian(endx,endy,len*.95,ang-ang0,size-.1);

//线段末点变为起始点长度缩小0.95倍，逆时针旋转，粗细将少0.1再次迭代画线 } }

woxuanquxian(startx,starty,startlen,startang,startsize); zhankaibtn.addEventListener(MouseEvent.CLICK ,clf1); function clf1(e) {

graphics.clear();//要先清屏

ang0=ang0*.8;//旋转角减小，曲线展开

woxuanquxian(startx,starty,startlen,startang,startsize); }

heshangbtn.addEventListener(MouseEvent.CLICK ,clf2); function clf2(e) { graphics.clear();

ang0实例94 分形的研究---圆内任意多个小圆迭代效果

var startx:Number=50;//开始点初坐标 var starty:Number=550;

var startlen:Number=100;//第一条线段初始长度 var startang:Number=0;//第一条线段初始倾斜角 var startsize:Number=5;//第一条线段初始粗细 var color:uint;

var ang0=Math.PI/4;//初始逆时针旋转角

function woxuanquxian(xx:Number ,yy:Number ,len:Number ,ang:Number ,size:Number ) {

if (len>10) {

color=0xffffff*Math.random(); graphics.lineStyle(size,color); graphics.moveTo(xx,yy);

var endx:Number=xx+Math.cos(ang)*len;

var endy:Number=yy+Math.sin(ang)*len; graphics.lineTo(endx,endy);

woxuanquxian(endx,endy,len*.95,ang-ang0,size-.1);

//线段末点变为起始点长度缩小0.95倍，逆时针旋转，粗细将少0.1再次迭代画线 } }

woxuanquxian(startx,starty,startlen,startang,startsize); zhankaibtn.addEventListener(MouseEvent.CLICK ,clf1); function clf1(e) {

graphics.clear();//要先清屏

ang0=ang0*.8;//旋转角减小，曲线展开

woxuanquxian(startx,starty,startlen,startang,startsize); }

heshangbtn.addEventListener(MouseEvent.CLICK ,clf2); function clf2(e) { graphics.clear();

ang0实例95 分形的研究---圆外部小圆的迭代效果一

function circle(x0,y0,r) {

graphics.lineStyle(2,0xff0000);

graphics.beginFill(0xffffff*Math.random ()); graphics.drawCircle(x0,y0,r); graphics.endFill(); }

//diedai(200,250,50,0,0); var N=4;

function diedai(xx:Number ,yy:Number ,r:Number ,ang,n) { if (n//ang是每个大圆右边的小圆相对于大圆的倾斜角迭代开始初始值为0即图中的右圆的倾斜角

circle(xx,yy,r);//先画中间的一个大圆

var x1=xx+1.5*r*Math.cos(ang);//右边的小圆的坐标 var y1=yy+1.5*r*Math.sin(ang);

var x2=xx+1.5*r*Math.cos(ang-1/2*Math.PI);//上面的小圆的坐标 var y2=yy+1.5*r*Math.sin(ang-1/2*Math.PI);

var x3=xx+1.5*r*Math.cos(ang-Math.PI);//左边小圆的坐标 var y3=yy+1.5*r*Math.sin(ang-Math.PI); r=r/2;//三个小圆的半径 circle(x1,y1,r);//画三个小圆 circle(x2,y2,r); circle(x3,y3,r);

var ang1:Number=Math.atan2(y1-yy,x1-xx);//计算大圆右边的圆心相对于大圆的倾斜角作为下次迭代的初始角度

var ang2:Number=Math.atan2(y2-yy,x2-xx);//计算上面的圆心相对于大圆的倾斜角 var ang3:Number=Math.atan2(y3-yy,x3-xx);//计算左面的圆相对于大圆的倾斜角 diedai(x1,y1,r,ang1+1/2*Math.PI,n+1);//因为当右边的小圆作为新的大圆时候，新的右边的小圆在新的大圆的下面，即倾斜角增加90度

diedai(x2,y2,r,ang2+1/2*Math.PI,n+1);//旋转规律是右边的变下面的，上面的边右边的，左边的变上面的即依次都是增加九十度 diedai(x3,y3,r,ang3+1/2*Math.PI,n+1); } }

//通过循环得到整个图形效果 function initf() {

circle(300,300,100);//生成中间最大的一个圆，注意这个圆和周围的四个圆都不参与迭代，周围的四个只是初始元 for (var i:int =0; i<4; i++) {

var xxx:Number=300+150*Math.cos(Math.PI/2*i); var yyy:Number=300+150*Math.sin(Math.PI/2*i); diedai(xxx,yyy,50,(i+1)*1/2*Math.PI,0);

//i=0时画的右边的部分，可以看出初始时大圆右边的小圆在大圆的下面即初始倾斜角为90

//i=1时，画的是下面的部分即初始的大圆是下面的圆。它的右边的圆在左边相对于它的倾斜角是180

//i=2时，画的是左面的部分即初始的大圆是左面的圆。它的右边的圆在上边相对于它的倾斜角是270

//i=3时，画的是上面的部分即初始的大圆是上面的圆。它的右边的圆在右边相对于它的倾斜角是360 } }

//也可以把画线添加到一个容器里，调用迭代函数相同的的四次初始角度都为0，然后通过旋转容器得到四部分

addEventListener(Event.ENTER_FRAME ,frame); //先调用一次

addbtn.addEventListener(MouseEvent.CLICK ,clf); subbtn.addEventListener(MouseEvent.CLICK ,clf); function clf(e) {

if (e.target.name==\"addbtn\") { N<6?N++:0; } else { N>0?N--:0; }

addEventListener(Event.ENTER_FRAME ,frame);

//不直接调用initf函数而添加帧频函数调用的好处是可以时刻改变颜色达到绚丽的效果

}

function frame(e) { graphics.clear(); initf(); }

圆外部小圆迭代效果二 function circle(x0,y0,r) {

graphics.lineStyle(2,0xff0000);

graphics.beginFill(0xffffff*Math.random ()); graphics.drawCircle(x0,y0,r); graphics.endFill(); }

var N=4;

function diedai(xx:Number ,yy:Number ,r:Number ,ang,n) { if (n//ang是每个大圆右边的小圆相对于大圆的倾斜角迭代开始初始值为0即图中的右圆的倾斜角

circle(xx,yy,r);//先画中间的一个大圆

var x1=xx+1.44*r*Math.cos(ang-18*Math.PI/180);//右边的小圆的坐标注意都是从右开始逆时针方向所以都为减

var y1=yy+1.44*r*Math.sin(ang-18*Math.PI/180);

var x2=xx+1.44*r*Math.cos(ang-1/2*Math.PI);//上面的小圆的坐标 var y2=yy+1.44*r*Math.sin(ang-1/2*Math.PI);

var x3=xx+1.44*r*Math.cos(ang-162*Math.PI/180);//左边小圆的坐标 var y3=yy+1.44*r*Math.sin(ang-162*Math.PI/180); r=r*.44;//三个小圆的半径 circle(x1,y1,r);//画三个小圆 circle(x2,y2,r); circle(x3,y3,r);

var ang1:Number=Math.atan2(y1-yy,x1-xx);//计算大圆右边的圆心相对于大圆的倾斜角作为下次迭代的初始角度

var ang2:Number=Math.atan2(y2-yy,x2-xx);//计算上面的圆心相对于大圆的倾斜角 var ang3:Number=Math.atan2(y3-yy,x3-xx);//计算左面的圆相对于大圆的倾斜角 diedai(x1,y1,r,ang1+72*Math.PI/180,n+1);//因为当右边的小圆作为新的大圆时候，新的右边的小圆在新的大圆的下面，即倾斜角增加90度

diedai(x2,y2,r,ang2+72*Math.PI/180+18*Math.PI/180,n+1);//旋转规律是右边的变下面的，上面的边右边的，左边的变上面的即依次都是增加九十度 diedai(x3,y3,r,ang3+72*Math.PI/180+18*Math.PI/180,n+1); } }

//通过循环得到整个图形效果 function initf() {

circle(300,300,100);//生成中间最大的一个圆，注意这个圆和周围的四个圆都不参与迭代，周围的四个只是初始元

for (var i:int =0; i<5; i++) {

var xxx:Number=300+150*Math.cos(72*Math.PI/180*i-18*Math.PI/180); var yyy:Number=300+150*Math.sin(72*Math.PI/180*i-18*Math.PI/180); diedai(xxx,yyy,50,(i+1)*72*Math.PI/180,0); ////i=0时画的右边的部分，可以看出初始时大圆右边的小圆在大圆的下面即初始倾斜角为90

////i=1时，画的是下面的部分即初始的大圆是下面的圆。它的右边的圆在左边相对于它的倾斜角是180

////i=2时，画的是左面的部分即初始的大圆是左面的圆。它的右边的圆 在上边相对于它的倾斜角是270

////i=3时，画的是上面的部分即初始的大圆是上面的圆。它的右边的圆在右边相对于它的倾斜角是360 } }

//////也可以把画线添加到一个容器里，调用迭代函数相同的的四次初始角度都为0，然后通过旋转容器得到四部分

addEventListener(Event.ENTER_FRAME ,frame); ////先调用一次

addbtn.addEventListener(MouseEvent.CLICK ,clf); subbtn.addEventListener(MouseEvent.CLICK ,clf); function clf(e) {

if (e.target.name==\"addbtn\") { N<6?N++:0; } else { N>0?N--:0; }

addEventListener(Event.ENTER_FRAME ,frame);

//不直接调用initf函数而添加帧频函数调用的好处是可以时刻改变颜色达到绚丽的效果 }

function frame(e) { graphics.clear(); initf(); }

实例96 分形的研究---任意正多边形的渐开线

//==========画正多边形

function duobianxing(N:int,R:Number,X:Number,Y:Number ,ang:Number ) { //参数为正多边形的边数，半径和中心坐标 多边形起点的倾斜角 graphics.lineStyle(2,0xffffff*Math.random ()); //graphics.beginFill(0xffffff*Math.random ());

graphics.moveTo(X+R*Math.cos(ang),Y+R*Math.sin(ang)); for (var i:int=0; ivar yy:Number=Y+R*Math.sin((i+1)*Math.PI*2/N+ang); graphics.lineTo(xx,yy); } }

////============,画弧线函数

function jiankaixian(centerx,centery,startx,starty,r,ang,ang0) {//参数分别是圆心坐标，画弧线起始点坐标，半径，打开的最大角度，起始点的角度 graphics.lineStyle(3,0xffffff*Math.random ()); graphics.moveTo(startx,starty); for (var i:int =0; igraphics.lineTo(centerx+r*Math.cos (i*Math.PI

/180+ang0),centery+r*Math.sin (i*Math.PI /180+ang0)); } }

var N:int=7;//初始迭代次数 var num=6;//正多边形的边数

var rr:Number=100;//初始最大正多边形的半径 //==============迭代生成效果

function diedai(m:int,r:Number,x0:Number ,y0:Number,ang,n:int) {//多边形的起点倾斜角

var len:Number=2*r*Math.sin(Math.PI/num); if (nvar x1:Number=x0+r*Math.cos(ang+n*Math.PI*2/num);//正多边形的起点作为渐开线的起点

var y1:Number=y0+r*Math.sin(ang+n*Math.PI*2/num);

var x2:Number=x0+r*Math.cos(ang+(n+1)*Math.PI*2/num);//渐开线的首段弧的开始圆心

var y2:Number=y0+r*Math.sin(ang+(n+1)*Math.PI*2/num);

var ang1:Number=Math.atan2(y1-y2,x1-x2);//起点1相对于圆心2的角度

jiankaixian(x2,y2,x1,y1,len*n,360/num,ang1);//注意渐开线的打开范围角度单位是度，弧线起始点的角度单位是弧度

//每部分渐开弧线的圆心，起点，半径都随着迭代次数n的改变而改变

diedai(m,r,x0,y0,ang,n+1);//注意迭代过程中正多边形的边数m，多边形的半径，多边形的中心坐标，多边形的起始点角度 //都不改变，只有迭代次数n在改变 } }

//==================

addEventListener(Event.ENTER_FRAME ,frame); addbtn.addEventListener(MouseEvent.CLICK ,clf); subbtn.addEventListener(MouseEvent.CLICK ,clf); addnumbtn.addEventListener(MouseEvent.CLICK ,clf); subnumbtn.addEventListener(MouseEvent.CLICK ,clf); function clf(e) {

if (e.target.name==\"addbtn\") { N++;//迭代次数小于5 }

if (e.target.name==\"subbtn\") { N>0?N--:0; }

if (e.target.name==\"addnumbtn\") { num++; }

if (e.target.name==\"subnumbtn\") { num>0?num--:0; }

addEventListener(Event.ENTER_FRAME ,frame);

//不直接调用initf函数而添加帧频函数调用的好处是可以时刻改变颜色达到绚丽的效果 }

function frame(e) { graphics.clear();

diedai(num,100,300,300,0,1); duobianxing(num,100,300,300,0); }

实例97 方块小游戏

//可以让每个小方块后面藏一个小奖品

var jiang:MovieClip = new Jiangpin();//把奖品实例画出来 jiang.width=35; jiang.height=35;

////保存八个方块的横纵坐标

var xCorrd:Array=[20,60,100,100,100,60,20,20]; var yCorrd:Array=[100,100,100,60,20,20,20,60]; //参数为数组的长度

var arrSquares:Array=new Array(xCorrd.length); var delay:Number=400;

var tm:Timer=new Timer(delay);

tm.addEventListener(TimerEvent.TIMER ,move);

tm.addEventListener(TimerEvent.TIMER_COMPLETE,moveDone); var spaceIndex:int=0;//小球运行时每个时刻的坐标索引值 //创建游戏面板

var gameBoard:Sprite =new Sprite(); addChild(gameBoard);

gameBoard.scaleX=2;//让游戏面板放大 gameBoard.scaleY=2; gameBoard.x=80; gameBoard.y=50;

for (var i:int =0; iarrSquares[i].filters =[new BevelFilter()]; arrSquares[i].graphics.lineStyle(1,0x000000); arrSquares[i].graphics.beginFill(0x000000); arrSquares[i].graphics.drawRect(-20,-20,40,40); arrSquares[i].graphics.endFill(); arrSquares[i].x=xCorrd[i]; arrSquares[i].y=yCorrd[i];

gameBoard.addChild(arrSquares[i]); }

//z中间的那个方块

var mc:Sprite =new Sprite();

mc.graphics.lineStyle(1,0x000000); mc.filters =[new BevelFilter()]; mc.graphics.beginFill(0x00fffff); mc.graphics.drawRect(-20,-20,40,40); mc.x=60; mc.y=60;

gameBoard.addChild(mc);

//默认是动态的文本，要想是输入的可以设置格式 var txtCount:TextField =new TextField(); txtCount.x=-10;//要位于中心 txtCount.y=-10; txtCount.width=20; txtCount.height=25;

txtCount.mouseEnabled=false;

//因为点击事件是针对中间的方块而不是文本 //所以不接受鼠标事件或者用mc。mouseChildren=false即mc的子对象不接受鼠标事件 txtCount.defaultTextFormat=new TextFormat(\"Arial\ //参数分别是字体，大小，颜色， //点击方块前看不见文本

//如果文本没有内容就用这个属性

//如果文本内已经有内容可以用方法：txtCount.setTextFormat() txtCount.autoSize=\"center\"; txtCount.visible=false; mc.addChild(txtCount);

//如果不接受鼠标事件也不做容器就可以用最简单的shape var ball:Shape =new Shape(); ball.graphics.lineStyle(1);

ball.graphics.beginFill(0xffffff); ball.graphics.drawCircle(0,0,10); ball.graphics.endFill(); //初始化小球位置

ball.x=xCorrd[0]; ball.y=yCorrd[0];

gameBoard.addChild(ball); gameBoard.addChild(jiang); jiang.visible=false;

mc.addEventListener(MouseEvent.CLICK ,clf); function clf(e) {

jiang.visible=false;//点击后奖品不可见 ball.visible=true;

//gameBoard.removeChild(jiang)

//产生一个随机值，文本可见，小球运动，并且小球运动的时候不能支持再点击 //计时器开始运行，运行的次数等于小球运动的次数 var rn:int=Math.random()*7+3;//产生3到9的随机数字 txtCount.text=String(rn); txtCount.visible=true;

mc.removeEventListener(MouseEvent.CLICK ,clf);

tm.reset();//每次点击要把即计时器归零因为计时器次数会累加 tm.repeatCount=rn;//计时器的运行次数等于随机值 tm.start(); }

function move(e) {

//让索引值在1到8之间变化

spaceIndex=(spaceIndex+1)%(xCorrd.length ); ball.x=xCorrd[spaceIndex]; ball.y=yCorrd[spaceIndex]; }

function moveDone(e) {//小球停止后，重新添加点击事件 jiang.visible=true;//停止后出现奖品，小球隐藏 jiang.gotoAndStop(int(Math.random ()*8)+1);

gameBoard.setChildIndex(jiang,gameBoard.numChildren -1); ball.visible=false; jiang.x=ball.x; jiang.y=ball.y;

txtCount.visible=false;

mc.addEventListener(MouseEvent.CLICK ,clf); }

实例98 打方块小游戏

stage.frameRate=30; var boardX:Number=0; var boardY:Number=0; var cuo:uint=0;

var boardArr:Array=new Array(); var dis:Number=0;

var boardspd:int=10; var vx:int=5; var vy:int=5;

for (var j:uint=0; j<10; j++) { for (var i:uint=0; i<12; i++) { var board:Board=new Board(); board.x+=i*board.width+cuo*24; board.y+=j*board.height+8; addChild(board);

boardArr.push(board); }

if (cuo==0) { cuo=1; } else { cuo=0; } }

this.addEventListener(Event.ENTER_FRAME,downboardmove); function downboardmove(e:Event) { dis=mouseX-downboard.x; if (dis>boardspd) {

downboard.x+=boardspd; }

if (disball.x-=vx; ball.y-=vy;

if (ball.x+ball.width/2>stage.stageWidth) { vx=vx*-1; }

if (ball.x-ball.width/2<0) { vx=vx*-1; }

if (ball.y-ball.height/2<0) { vy=vy*-1; }

if (ball.y+ball.height/2>stage.stageHeight) { vy=vx=0;

this.removeEventListener(Event.ENTER_FRAME,downboardmove); }

if (downboard.hitTestObject(ball)) { vy*=-1; }

for (var i:int=0; i实例99 开奖

var i:int=0;//控制开号总次数 var m:int=0;//控制中奖总次数 var n:Number=0;//控制总金额 var k:Number=0;//控制总奖金

tishi_txt.visible=false;//提示信息不可见 guize_mc.visible=false;

shuru_txt.restrict=\"1-6\";//输入号码限制为1到6

shuru_txt.maxChars=1;//输入限制为一个字符即只为1到6之间的整数值 shuru_txt.text=\"\"; jiangjin_txt.text=\"\";

addEventListener(Event.ENTER_FRAME ,gb);

function gb(e:Event ):void {//光标初始默认为输入文本框 stage.focus=shuru_txt;

if (shuru_txt.length==1) {//如果输入完成一个字符再 删除该事件 removeEventListener(Event.ENTER_FRAME ,gb); stage.focus=touru_txt;//光标自动跳到投注文本框 } }

kaijiang.addEventListener(MouseEvent.CLICK ,f);//开号按钮添加事件 function f(e) {

if (shuru_txt.text==\"\"||touru_txt.text==\"\") {//如果输入号码和投入资金有一个为空则显示提示信息 shuru_txt.text=\"\"; touru_txt.text=\"\"; tishi_txt.visible=true;

tishi_txt.text=\"请输入完整的的\\n号码和投注资金\"; } else {

i++;//如果输入信息完整则总次数开始累加计算

kaijiang_txt.text=String(int(Math.random()*6+1));//开号为0到6的任意一个随机数字 zongshu_txt.text=\"\"+i;//总次数文本显示 tishi_txt.visible=false;//提示信息隐藏

kaijiang.removeEventListener(MouseEvent.CLICK ,f);//因为一次投注只能开好一次 //为了防止重复开号删除，开号成功后删除侦听事件 }

if (Number(kaijiang_txt.text)==Number(shuru_txt.text)&&Number(kaijiang_txt.text)!=0) {

m++;//如果开号号码和输入号码一样并且不是空则中奖次数开始累加 zhongjiang_txt.text=\"\"+m;

jiangjin_txt.text=\"\"+Number(touru_txt.text)*5;//本次奖金显示为本次投资的五倍 kaijiang.removeEventListener(MouseEvent.CLICK ,f);//删除事件 }

if (Number(kaijiang_txt.text)!=Number(shuru_txt.text)) {//如果开号码和输入号码不一致则本次奖金为0 jiangjin_txt.text=\"\"+0; tishi_txt.visible=true;

tishi_txt.text=\"谢谢参与\";

kaijiang.removeEventListener(MouseEvent.CLICK ,f); }

var j:Number=Number(touru_txt.text);//保存本次投注金额 var h:Number=Number(jiangjin_txt.text);//保存本次奖金金额 n+=j;//总投注累加本次投注 k+=h;//总奖金累加本次奖金

zongjin_txt.text=\"\"+n;//文本分别显示出来 zongjiang_txt.text=\"\"+k;

i==0?mingzhonglv_txt.text=\"\"+0:mingzhonglv_txt.text=\"\"+m/i;//当i等于0时候会出现命中率为无穷大的值所以限制此时为0 zonglirun_txt.text =\"\"+(k-n); }

btn.addEventListener(MouseEvent.CLICK ,ff);//重来按钮添加重新开始事件 function ff(e) {

tishi_txt.visible=false;

kaijiang.addEventListener(MouseEvent.CLICK ,f);//添加开号事件 shuru_txt.text=\"\";

kaijiang_txt.text=\"\";//有关文本显示空 touru_txt.text=\"\"; jiangjin_txt.text=\"\";

addEventListener(Event.ENTER_FRAME ,gb);//重新添加光标控制函数 }

guize_btn.addEventListener(MouseEvent.MOUSE_MOVE,movef); function movef(e) { tishi_txt.visible=false; guize_mc.visible=true; }

guize_btn.addEventListener(MouseEvent.MOUSE_OUT,outf); function outf(e) {

tishi_txt.visible=false;//防止提示信息和规则重叠出现 guize_mc.visible=false; }

实例100 算盘

每穿算盘珠上的代码

var arry:Array=[];//记录七个算盘珠子的开始纵坐标数组 for (var i:int=0; i<7; i++) {

var mc:MovieClip=getChildByName(\"mc\"+i) as MovieClip;

//按照原件的名字获取对象时候 注意要强制转换成MovieClip形式否则报错 mc.buttonMode=true; var yy:Number=mc.y; arry.push(yy); //trace(yy); }

var arrBo:Array=[];//存放七个珠子开始坐标状态时为真 for (i=0; i<7; i++) { var bo:Boolean=true; arrBo.push(bo); }

function dong() {//开始状态是上面两个在上面，下面七个在下面

arrBo[0]==true?mc0.y=arry[0]:mc0.y=arry[0]+80;//如果每个珠子的状态值为真则在开始时候的纵坐标，否则

arrBo[1]==true?mc1.y=arry[1]:mc1.y=arry[1]+80;//上面两个则向下平移 arrBo[2]==true?mc2.y=arry[2]:mc2.y=arry[2]-160;//下面五个向下平移 arrBo[3]==true?mc3.y=arry[3]:mc3.y=arry[3]-160; arrBo[4]==true?mc4.y=arry[4]:mc4.y=arry[4]-160; arrBo[5]==true?mc5.y=arry[5]:mc5.y=arry[5]-160; arrBo[6]==true?mc6.y=arry[6]:mc6.y=arry[6]-160 ; }

mc0.addEventListener(MouseEvent.MOUSE_DOWN ,df0);

function df0(e) {//因为每个珠子只有两个状态值，原来状态和平移后的状态

arrBo[0]=! arrBo[0];//每次点击都要给布尔值取反，即小球要不在原来的状态要不发生平移

arrBo[0]==false?arrBo[1]=false:0;//当点击第0号珠子时候，一号珠子的状态如果是真，即

//一号珠子在开始的位置即上移，这样就和0号珠子就会重合，因此让0号的布尔值取反，这样就也同时向下平移 dong(); }

mc1.addEventListener(MouseEvent.MOUSE_DOWN ,df1); function df1(e) { arrBo[1]=! arrBo[1];

arrBo[1]==true?arrBo[0]=true:0;//当点击一号如果值为真

//说明要回到原来的位置因此0号小球也要同时回到原来的位置 dong();

}

mc2.addEventListener(MouseEvent.MOUSE_DOWN ,df2); function df2(e) { arrBo[2]=! arrBo[2];

arrBo[2]==true?[arrBo[3]=true,arrBo[4]=true,arrBo[5]=true,arrBo[6]=true]:0; //当二号珠子值为真时候，则说明要回到原来的位置即下移，

//那么让下面的珠子值都为真，即都下移回到初始位置下面的同理 dong(); }

mc3.addEventListener(MouseEvent.MOUSE_DOWN ,df3); function df3(e) { arrBo[3]=! arrBo[3];

arrBo[3]==true?[arrBo[4]=true,arrBo[5]=true,arrBo[6]=true]:0; arrBo[3]==false?arrBo[2]=false:0; //当三号珠子值为假时候，说明要上移，则上面的珠子即二号珠子也要同时上移下面同理 dong(); }

mc4.addEventListener(MouseEvent.MOUSE_DOWN ,df4); function df4(e) { arrBo[4]=! arrBo[4];

arrBo[4]==true?[arrBo[5]=true,arrBo[6]=true]:0; arrBo[4]==false?[arrBo[3]=false,arrBo[2]=false,]:0; dong(); }

mc5.addEventListener(MouseEvent.MOUSE_DOWN ,df5); function df5(e) { arrBo[5]=! arrBo[5];

arrBo[5]==true?arrBo[6]=true:0;

arrBo[5]==false?[arrBo[4]=false,arrBo[3]=false,arrBo[2]=false,]:0; dong(); }

mc6.addEventListener(MouseEvent.MOUSE_DOWN ,df6); function df6(e) { arrBo[6]=! arrBo[6];

arrBo[6]==false?[arrBo[5]=false,arrBo[4]=false,arrBo[3]=false,arrBo[2]=false,]:0; dong(); }

//==========全部珠子还原到初始状态函数

function fuyuan() {//此函数写到了元件内部而不调用可以在主场景通过该元件的方法来调用

arrBo[0]=arrBo[1]=arrBo[2]=arrBo[3]=arrBo[4]=arrBo[5]=arrBo[6]=true; dong(); }

//场景中的代码本动画的重点就是在元件内部自定义函数，在主场景通过类得方法来调用

var sp:Sprite =new Sprite(); addChild(sp);

for (var i:int =0; i<11; i++) { var zhu:Zhu=new Zhu(); sp.addChild(zhu);

zhu.scaleX=zhu.scaleY=0.4; zhu.x=102+i*(145.80-113.9); zhu.y=140; }

btn.buttonMode=true;

btn.addEventListener(MouseEvent.CLICK ,fuyuanf); function fuyuanf(e) { for (i =0; i<11; i++) {

var zhu:Zhu=sp.getChildAt(i) as Zhu;//按照层深获取并强制转化成类格式 //通过类方法的形式调用元件内部得自定义函数

//var zhu:MovieClip=sp.getChildAt(i) as MovieClip;强制转化成影片也可以 zhu.fuyuan(); } }