Flash理論課復習具體內容

02.jpg

題型

1. 單選 20*2=40
2. 程序填空題 4*10=40
3. 編程題 10
4. 簡述題 10

書本章節

一、第一章

1.關于flash的基本操作 常用快捷鍵 shift+橢圓工具 ctrl+enter f5 f6 f7 f9 ctrl+d

shift+拉伸    橢圓變正圓
ctrl+enter  運行flash
f5      普通幀
f6      關鍵幀
f7      空白關鍵幀
f9      代碼窗口
ctrl+d      復制對象

2.工具欄的使用 形變動畫 分離 補間 3種幀 普通幀 空白關鍵幀 關鍵幀

a.空白幀：表示當前時間軸面板上的某一個圖層沒有幀。
b.傳統補間：該狀態表示在兩個關鍵幀之間成功創建了“傳統補間動畫”
c.形狀補間：淺綠色底紋表明創建的補間為“補間形狀”。
d.普通幀：以關鍵幀開始，以矩形顯示的普通幀結束，表明在這兩個幀之間持續顯示第一個關鍵幀的內容。
e.添加語句：為了控制動畫播放，會在幀上添加腳本語句。添加了腳本語句的幀上會顯示“a”標簽。
f.注釋：選擇一個幀，在屬性面板的“注釋”一項輸入文字，即為該幀添加了注釋。
g.補間動畫：在Flash中，為元件創建補間后，幀的顯示為此狀態。
h.波形幀：此幀用于表示聲音文件。

關于幀

(1)普通幀(F5)：

普通幀在時間軸中用空心矩形表示。普通幀的主要作用是重復顯示前一幀的內容而不做改變。

(2)關鍵幀(F6) ：

關鍵幀在時間軸上用實心圓點表示。關鍵幀定義了動畫中的關鍵畫面 ，關鍵幀除了具備重復顯示前一幀內容的作用之外，還允許用戶對關鍵幀中的內容進行修改。

(3)空白關鍵幀(F7) ：

空白關鍵幀在時間軸上用空心的圓點表示。空白關鍵幀具備有關鍵幀的屬性，但空白關鍵幀不會重復顯示前一幀的內容，而是在空白關鍵幀所處的當前幀起不再顯示前面幀的內容，將舞臺清空，便于用戶制作后續的畫面內容，用戶一旦在空白關鍵幀中添加了內容，空白關鍵幀將會自動轉變為關鍵幀。

3.元件的3種 多個幀 1個幀 4個幀熱區！

元件分為三種類型：影片剪輯元件、按鈕元件和圖形元件

1）影片剪輯元件

影片剪輯元件用于創建一類可以被用戶重復使用的動畫片段。影片剪輯元件有獨立的時間軸面板，用戶可以直接在影片剪輯元件編輯中制作動畫片段，其制作方法與場景中動畫的制作方法相同。影片剪輯元件雖然是一個動畫片段，制作過程中需要使用**多個幀**來完成，但將影片剪輯元件應用于其他對象時，只占用一個幀的位置，但播放時卻同樣具有動態效果。

影片剪輯元件中可以使用聲音、視頻、圖形和文字等等各種媒體素材。

2）按鈕元件

按鈕元件是用戶與動畫的接口，用戶通過按鈕元件及動作腳本語句可以輕松實現人機交互的效果。新建一個按鈕元件后進入到按鈕元件的編輯窗口，按鈕元件有四個幀

**彈起：**是按鈕的普通顯示狀態。即用戶鼠標還未觸發按鈕時的顯示狀態。
**指針經過：**該幀中的內容由用戶的鼠標移動經過按鈕時觸發。
**按下：**用戶單擊鼠標時按鈕的顯示狀態。
**點擊：**該幀定義響應鼠標單擊的區域。

按鈕元件中經常使用到的媒體素材有聲音文件和圖形文件等各種類型。

（3）圖形元件

一般為矢量圖形、位圖和文字等對象。**一個幀**

圖形元件的編輯窗口與場景的編輯窗口相同。用戶如果將交互控制和聲音素材放于圖形元件中，但卻無原有的動態效果。

4.導入外部圖片素材 主要圖片格式 jpg bmp gif png 導入舞臺 哪個是動態圖？會變成逐幀動畫？

只有gif是逐幀動畫 其他都是靜態

5.幀頻FPS 每秒播放的幀數 圖層，常見的圖層類型 普通圖層 遮罩圖層、引導圖層——至少不止一層

**遮罩動畫至少有2個層 遮罩層和被遮罩層**

幀頻 = frequent per second

6.繪制矢量圖的方法

矩形、橢圓形工具、鋼筆工具

7.元件 重點掌握 元件的優勢

1.一次制作、反復使用
2.無論元件加多少個都不會增加文件的容量
3.在as3.0用代碼直接當類生成導出，方便創建對象

8.實例和元件的關系 類、對象、屬性

實例能直接使用-實例名.屬性，進行操作 如：myText.text = "hello";
元件要通過類引用新建為對象，再對對象的屬性操作，如： var myTitle:Text = new Text();myTitle.text = "yooooooo";

9.動畫的導出 可以導出swf 嵌入網頁 導出很多不同類別的文件 測試導出時的3類文件.fla .swf .as這3類文件

導出文件，格式相關的東西需要謹記

10.as3代碼的位置 時間軸上、時間軸的幀上、專門的腳本文件

如果是在時間軸上面用F9插入了代碼 那個幀上面就會有a符號
如果是在外部鏈接了as文件，則舞臺上會直接關聯一個as腳本

//在屏幕上打印出一段文字的代碼
package {
    //導入所需的類
    import flash.display.Sprite;
    import flash.text.*;
    //定義類
    public class Main extends Sprite {
        //聲明一個文本變量
        public var myText:TextField = new TextField();
        //創建一個與類名稱一致的方法
        public function Main() {
            //定義文本內容
            myText.autoSize = TextFieldAutoSize.LEFT;
            myText.text = "HELLO MY FLASH";
            //定義文本的樣式
            var myFormat:TextFormat = new TextFormat();
            myFormat.size = 50;
            myFormat.font = "Cooper Black";
            myFormat.color = 0x005588;
            //定義文本位置
            myText.x=50
            myText.y=150
            //應用定義的樣式
            myText.setTextFormat(myFormat);
            //在舞臺上創建顯示對象
            addChild(myText);
        }
    }
}

二、第二章(重點)

1.變量定義的方法
2.變量的命名規則

關于變量

變量指的是在程序中可以發生變化的量，實際上，變量是內存中存儲數據的容器，用來存儲在程序中需要使用的值。
在 ActionScript 3.0中，變量在使用時需要先定義

變量的三大要素：名稱、類型、值

變量的定義

格式： var  變量名：數據類型名；

var：定義變量的關鍵字

變量名：用戶命名的一串有效的標識，規則如下：

1.必須以字母開頭，且只能由字母、數字和下劃線“_”組成，一般采用 “駱駝命名法”命名形式：首字母小寫，組成變量名的其他單詞的首字母大寫，單詞其他字母小寫。如myText （嚴格區分大小）；
2.變量名不易太長，盡量做到以最小長度傳達最大信息量的目的。如：userName和myAge等
3.變量名要做到唯一使用；
4.不能使用ActionScript3.0中的關鍵字作為變量的名稱

數據類型名：不同數據類型有特定的類型名， var i: int;

1.在對變量進行聲明時，還可以使用賦值運算符“＝”直接為變量賦值。如：
　　　　　　var n:Number;
　　　　　　n=3;
或
　　　　　　var n:Number=3;　　　

2.如果要同時聲明多個變量 ， 可以使用逗號運算符（,）來對變量進行分隔，此時可以在同一行代碼中為每個變量賦值。如：
       var a:int=5, b:Boolean=true, c:String=”My Word”;　　　

3.在創建數組時，往往需要在聲明數組的同時為數組賦值。此時可以使用下面的方法：
var myArray:Array=[”button”,”photo”];
var myArray:Array=new Array(元素1,元素2,……)
var myArray:Array=new Array();
        myArray[0]=1;
        myArray[1]=2;
        ………….

4.在創建類的實例時，需要在變量聲明的同時為變量賦值。此時可以使用new運算符來創建類的實例
如：下面的語句創建一個影片剪輯實例：

    var myMC:MovieClip =new MovieClip();

變量的作用域：變量使用的范圍，是指代碼在運行變量時可以被引用的區域；
分為“全局”和“局部”兩種；

1.全局變量是在任何函數或類定義的外部定義的變量，其在函數定義或類定義的外部和內部均可以使用。
2.局部變量是在函數中定義聲明的變量，這種在函數塊中定義的局部變量只能在函數內部使用，在函數外部不可用。

//示例代碼 全局變量與局部變量
>
var myText:String="全局變量";
function myTest() {
    trace(myText);
}
myTest();
trace(myText);
>
function myTest() {
    var myText:String="局部變量";
    trace(myText);
}
myTest();

常量

常量指的是在程序中固定不變的量。
常量可以看作是一種使用const關鍵字來進行聲明的特殊變量，其只能在聲明的同時進行賦值，一經賦值其值就不能改變。

當在程序中試圖對常量的值進行改變時，編譯器就會報錯。在編寫程序時，如果能夠確定一個變量的值不會發生改變，就可以將其定義為常量，以便編譯器來對其進行監督。

常量使用const關鍵字來聲明：

public stactic const PI:Number=3.1415927;

Flash Player API定義了一組常量供程序員使用，
這些常量全部使用大寫字母，各個單詞之間以下劃線“_”來連接 。

//常量的示意代碼
package flash.events
{
    public class MouseEvent extends Events
    {
        public static const MOUSE_MOVE:String=”mouseMove”;
    }
}

3.數據類型的轉換 int sting boolean=true\false

數據類型就是表明一個變量可存儲信息的種類。分為：

1.基元型數據類型是值類型數據；
2.基元型數據主要指布爾型、字符串型、整型和數值型等。
3.復雜型數據類型是引用類型數據；
4.復雜型數據包括對象型、數組型、日期型、錯誤對象、可擴充的標記語言對象等類型。

基元型數據類型比復雜型數據類型處理速度要快一些

1．數值型（Number）數據：用于存儲和表示數字，數值型數據是一種雙精度浮點數，包括整數、無符號整數和浮點數。數值型數據使用64位雙精度格式來存儲數據。默認值為NaN。
2．整型（int）數據：一組介于-2147483648和2147483647之間的整數。可以使用數字運算符進行數值處理。整型數據的變量默認值為0。
3．字符串型（String）數據：存儲字符對象，字符包括字母、數字和標點符號等。在語句書寫過程中，字符串需要使用雙引號搭配使用，將字符書寫在雙引號之內。使用“+”可以將多個字符串進行連接和合并。字符串型數據的變量默認值為null。
4．無符號整型（uint）數據：取值范圍為0-4294967295，是一個32位無符號整數。無符號數據類型的變量默認值為0。
5．布爾型（Boolean）數據：只有兩個值，即“真（true）”和“假(false)”。布爾類型的變量默認值為 false。
6．Null(空值)和void(未定義)數據類型：
Null數據類型只包含一個值Null，表示空，即沒有值
void數據類型只包含一個值undefined，表示一個變量沒有定義，該值只能賦予無類型變量（即缺乏類型注釋或使用*作為注釋的變量）。
7．Object數據類型：是ActionScript中所有類定義的基類。其實例的默認值是null。
8．*（無類型）：無類型變量只有一個值undefined。無類型數據用于用戶無法確定變量類型時，便可以使用*來表示當前定義的變量的類型未知。

數據類型的轉換

1.隱式轉換（自動轉換）

由flash player在運行時通過調用內部轉換算法自動轉換

var a:String = "4";
var b:Number = 5;
trace(a+b+5);
//結果：455
//將變量b和5自動轉換為String類型

2.顯式轉換（強制轉換）

通過編寫代碼指示編譯器將一種數據類型轉換為另一種類型

var a:String = "4";
var b:Number = 5;
trace(a*b);
//結果：出錯！
//改為：trace(int(a)*b);
//結果：20
//將變量a強制轉換為int類型

4.運算符 is\as

數據類型檢查符用于對數據類型進行檢測，其包括is運算符、as運算符、typeof運算符和in運算符。

is---測試變量或表達式是否為給定的數據類型,返回true或false

var mySprite:Sprite=new Sprite();
trace(mySprite is Sprite);-----------true
trace(mySprite is MovieClip);-------false

as---測試變量或表達式是否為給定的數據類型,返回表達式的值

var mySprite:Sprite=new Sprite();
trace(mySprite as Sprite);-----------[Object Sprite]
trace(mySprite as MovieClip);-------null

typeof---測試變量或表達式值的類型，返回數據類型名

var a:Number;
trace(typeof(a)); -----------number

in---判斷屬性是否為特定對象的一部分

trace("PI" in Math);-----------true

5.程序結構 選擇結構 if else if \switch case 循環結構 for in \foreach in 的區別

示例代碼

//if選擇結構
if(condition1){
    statements1;
}
else if (conditiont2){
    statements2;
}
else if (conditiont3){
    statements3;
}
else {
    statements n;
}

//switch選擇結構
switch(expression){
    case Clause1:
        statements1;break;
    case Clause2:
        statements2;break;
           default:
        statements;
}

//while循環結構
while (condition){
    statements;
}

//do while循環結構
do{
    statements;
}while(condition)

//for循環結構
for ([init];[condition];[next]){
    statements;
}

//for in 循環結構
for (variableIterant:String in object){
    statements;
}

//for each in 循環結構
for each(variableIterant in object){
    statements;
}

for in和for each in的區別

for each…in循環用于循環訪問集合中的項目，這個集合可以是XML或XMLList對象中的便簽、對象的屬性值或數組中的元素。
與
**for…in **語句不同，該語句的迭代變量包含屬性所包含的值，而不是屬性的名稱。

var jh:XML=<jhj>;
<mz> 廣東 </mz>;
<mz> 醫藥 </mz>;
<mz> 大學 </mz>;
</jhj>;
>
for each(var i:String in jh.mz){
    trace(i);
}
>
for(var j:String in jh.mz){
    trace(jh.mz[j]);
}
>
輸出：
廣東
醫藥
大學
廣東
醫藥
大學
>

6.函數 function my_fun()

ActionScript 3.0中有兩類函數：方法和函數閉包

方法：如果將函數定義為類定義的一部分或將函數附加到對象的實例，則該函數就稱為方法

函數閉包:以其他的任何方式定義函數，則該函數稱為函數閉包。在對象或類之外的位置執行函數，都會創建函數閉包

(1)函數語句
function 函數名(參數1:類型,參數2:類型…) {…………. }
例如：

function hs(cs:Number){
    trace(cs*10);
}
>
hs("hello world");

(2) 函數表達式
var 變量名:Function=function(參數1:類型,參數2:類型…) { …………. };
例如：

var hs:Function=function(shuju:String){
    trace(shuju);
};
>
hs("hello world");

值傳遞和引用傳遞的區別

>
//1.按值來傳遞參數
functin cs(a:int,b:int):void{
    a*=5;
    b*=6;
    trace(a,b);
}
var m:int=5,n:int=6;
cs(m,n);
trace(m,n);
>
//m,n的值沒改變
>
>
>
//2.按引用傳遞參數
function cs(myObj:Object):void{
    myObj.a*=5;
    myObj.b*=6;
    trace(myObj.a, myObj.b);
}
var objA:Object={a:5,b:6};
cs(objA);
trace(objA.a, objA.b);
>
//對象objA的a、b屬性值變為25和36
>
>
>
//3. 參數…（rest）
//參數…（rest）可以用來指定一個數組參數，以接受任意個逗號分隔的參數，參數聲明必須是最后一個指定的參數
var m:int = 0;
function cs(n:int,...abc)
{
    for (var i:uint=0; i<abc.length; i++) {
        m +=  abc[i];
    }
    trace(m);
}
cs(5,6,7,8,9);
>
//結果為n=5,abc[0]=6,abc[1]=7,abc[2]=8,abc[3]=9
//所以 6+7+8+9 =30
>
//4. 對象argumens
//對象argumens是一個數組，包含傳遞給函數的所有參數。在程序中，可以使用對象argumens來訪問有關傳遞給函數的參數信息。
var m:int = 0;
function cs(a:int,b:int,c:int){
    for (var i:uint=0; i< arguments.length; i++) {
        m +=  arguments[i];
    }
    trace(m);
}
cs(5,6,7);
>
//結果：18（5、6、7的和）
>

函數的嵌套和遞歸

function qiantao():String{
    function qiantaoA():String{
        return "這是";
    }
    function qiantaoB():String{
        return "函數的嵌套";
    }
    return qiantaoA()+ qiantaoB();
}
trace(qiantao());

函數的遞歸調用

function digui(x){
    if(x==0||x==1){
        return 1;
    }
    else{
        return x+digui(x-1);
    }
}
trace(digui(10));

三、第三章(重點)

1.鼠標事件 on over...
2.鍵盤事件 KEY_UP KEY_DOWN keyCode charCode KeyboardEvent
3.幀頻事件 ENTET_FRAME
4.計時器事件 Timer(間隔時間毫秒,循環次數) start() complete
5.事件處理函數 addEventListerner()
6.事件處理一般過程

| 事件 | 事件描述 |
| --- |: ----:|
| MouseEvent.CLICK | 用戶在交互對象上按下并釋放鼠標主按鍵時發生 |
| MouseEvent.DOUBLE_CLICK | 用戶在交互對象上快速連續按下并釋放鼠標主按鍵兩次時發生 |
| MouseEvent.MOUSE_DOWN | 用戶在交互對象上按下鼠標主按鍵時發生 |
| MouseEvent.MOUSE_UP | 用戶在交互對象上釋放鼠標主按鍵時發生 |
| MouseEvent.MOUSE_OVER | 用戶將鼠標光標移到交互對象上時發生 |
| MouseEvent.MOUSE_OUT | 用戶將鼠標光標移出交互對象時發生 |
| MouseEvent.MOUSE_MOVE | 用戶在交互對象上移動光標時發生 |
| MouseEvent.MOUSE_WHEEL | 用戶在交互對象上轉動鼠標滾輪時發生 |
| KeyboardEvent.KEY_DOWN | 用戶按下某個鍵時發生 |
| KeyboardEvent.KEY_UP | 用戶釋放某個鍵時發生 |
| ContexMenuEvent.MENU_ITEM_SELECT | 用戶在交互對象相關聯的上下文菜單選擇時發生 |
| Event.ENTER_FRAME | 以幀頻觸發 |
| TimerEvent.TIMER | Timer對象在每次達到指定時間間隔時發生 |
| TimerEvent.TIMER_COMPLETE | 將Timer實例設置為固定的間隔數，在達到最后依次間隔時觸發 |

Flash的事件處理過程

//定義偵聽器函數
function  eventResponse(eventObject:EventType):void {
                函數處理的代碼
}
//在事件目標上添加某種事件的偵聽器
eventTarget.addEventListener(EventType.EVENT_NAME, eventResponse);

使用startDrag()

startDrag()方法可以讓用戶拖動指定的對象，該對象將一直保持跟隨鼠標的可拖動狀態，直到使用stopDrag()方法停止拖動或有另外一個對象可拖動為止

使用方法：
對象.startDrag(lockCenter:Boolean,bounds:Rectangle)
lockCenter:Boolean—指定可拖動對象是否鎖定在鼠標位置中央，為true時，對象將鎖定在鼠標位置中央，否則，對象將鎖定在首次單擊該對象的位置上

>
Mouse.hide();                           //隱藏鼠標指針
var myCursor:myCur=new myCur();     // 創建myCur類的實例
>
//代碼中的stage可以用this代替，代表當前舞臺
stage.addChild(myCursor);           //放置自定義鼠標指針實例
stage.addEventListener(MouseEvent.MOUSE_MOVE,moveMycur);//創建事件偵聽器
>
function moveMycur(e:MouseEvent):void {
    //使用startDrag()方法拖動指針實例
    myCursor.startDrag(true);
}

使用mouseMove

Mouse.hide();
stage.addEventListener("mouseMove",moveCur);
function moveCur(m:MouseEvent ) {
    vLine.x = mouseX;    //垂直放置的線與鼠標x坐標重合
    hLine.y = mouseY;   //水平放置的線與鼠標y坐標重合
    scope.x = mouseX;    //瞄準器的坐標與鼠標重合
    scope.y = mouseY;
    m.updateAfterEvent();  //不是必需
}
//常量“mouseMove”相當于MouseEvent.MOUSE_MOVE
//updateAfterEvent()用于強制更新顯示畫面(不必等到下一幀)

元件有4種狀態，由4個用來描述響應與鼠標交互的關鍵幀表示

**Up(彈起)：**光標不在按鈕上時按鈕的狀態
**Over(指針經過)：**光標在按鈕上時按鈕的狀態
**Down(按下)：**光標在按鈕上鼠標按鍵按下時按鈕的顯示狀態
**Hit(點擊):**按鈕的熱區(制作透明按鈕，其形狀決定了按鈕的相應區域)。

與按鈕交互行為有關的幾個屬性：

**mouseEnable：**是否能捕獲鼠標事件
**useHandCursor：**手形指針是否顯示
**tabEnable：**按Tab鍵是否可以使按鈕依次獲得焦點

按鈕的4個狀態:彈起、指針經過、按下、點擊

Paste_Image.png

hitTestState的用法

//1.新建一個名為“響應區域”的影片剪輯元件，在該元件的“元件屬性”對話框中單擊“高級”按鈕，勾選“為ActionScript導出”復選框，在“類”文本框中輸入類名“hit_Area”
>
//2.在“正方體1”影片剪輯的時間軸面板中創建一個名稱為“動作”的新圖層，在其第1幀輸入以下代碼：
>
stop();
var hit_A:hit_Area=new hit_Area();   //創建hit_Area類的實例
hit_btn.**hitTestState** = hit_A;  //設置按鈕實例hit_btn的“點擊”幀
hit_btn.addEventListener(MouseEvent.MOUSE_OVER,playMC);  //添加事件偵聽器
function playMC(myEvent:MouseEvent){
    play();
}

KeyboardEvent類

在 ActionScript 3.0 中，任何對象都可以通過偵聽器的設置來鍵控加諸于對象的鍵盤動作，而與鍵盤相關的動作事件均歸屬于KeyboardEvent類

鍵盤事件有兩種類型：KeyboardEvent.KEY_DOWN事件和KeyboardEvent.KEY_UP事件

在編寫程序時， 通過獲取KeyboardEvent類對象的keyCode屬性和charCode屬性值，可以判斷按下的按鍵是哪個，以便觸發對應的動作

keyCode ：按鍵碼，為數值，對應鍵盤上的按鍵。
charCode：字符碼，該鍵在當前字符集中的數值。（默認字符集是 UTF-8，它支持 ASCII。）

keyCode值與字符值之間的主要區別：
1.按鍵碼表示鍵盤上的一個按鍵（如主鍵盤區中的數字8和*是同一個按鍵，具有相同的按鍵碼；而主鍵盤區中的數字8與小鍵盤上的 8不是同一個鍵，因此它們的按鍵碼不同）
2.字符碼代表計算機可讀取和呈現的特定字符（R 與 r 的字符字符碼是不同的）

stage.addEventListener(KeyboardEvent.KEY_DOWN,getCode);
function getCode(me:KeyboardEvent){
    char_txt.text=String(me.charCode);
        key_txt.text=String(me.keyCode);
    in_txt.text=String.fromCharCode(me.charCode);
}

注意：fromCharCode()方法傳回參數中Unicode字符碼代表的字符所組成的字符串

stage.addEventListener(KeyboardEvent.KEY_DOWN,showKey);
function showKey(me:KeyboardEvent){
    switch (me.keyCode){
        case Keyboard.UP :
            key_txt.text="UP鍵";
            break;
        case Keyboard.DOWN :
            key_txt.text="DOWN鍵";
            break;
        case Keyboard.LEFT :
            key_txt.text="LEFT鍵";
            break;
        case Keyboard.RIGHT :
            key_txt.text="RIGHT鍵";
            break;
    }
}

ActionScript 3.0中，Timer類在每次達到指定的時間間隔時都會觸發計時器事件；
首先用Timer方法創建Timer類的實例，設定產生計時器事件的時間間隔以及在停止前生成事件的次數

Timer類常用的屬性：

currentCount:int--計時器從0開始后觸發的總次數
delay:Number--計時器事件間的延遲時間，單位毫秒
repeatCount:int--計時器運行總次數，為0則為無限次
running:Boolean--計時器當前狀態，正在運行為true

Timer對象在每次達到指定的事件間隔時都會調度TimerEvent對象，該對象的事件類型是timer，用常量TimerEvent.TIMER來定義

當到達最后一次事件間隔時，會觸發timerComplete事件，該事件由TimerEvent.TIMER_COMPLETE常量定義

digital.gotoAndStop(11)
charc.stop()

//定義計時器，時間間隔為1000毫秒，重復10次
var delay:uint=1000
var repeat:uint=10
var myTimer:Timer=new Timer (delay,repeat)

//為【START】按鈕添加事件偵聽器和事件響應函數
btn_S.addEventListener(MouseEvent.CLICK,start_T)

//點擊事件偵聽器
function start_T(m:MouseEvent ):void{
    myTimer.reset();            //計時器復位
    myTimer.start();                      //開始計時
    charc.gotoAndStop(1);             //“角色”影片剪輯播放頭移到開頭
    digital.gotoAndStop(11);    //倒計時數字影片剪輯的播放頭回到初始位置
}

//定義事件偵聽器
myTimer.addEventListener(TimerEvent.TIMER,play_Digital);

//創建事件響應函數，每間隔1秒更改顯示數字
function play_Digital(e:TimerEvent ):void{
    digital.gotoAndStop(repeat);
    repeat--;
}

//添加TIME_COMPLETE事件偵聽器
myTimer.addEventListener (TimerEvent.TIMER_COMPLETE ,c_Down)
function c_Down(e:TimerEvent ):void{
    charc.play();
    repeat=10;
}

四、第四章

1.對象的添加\移除 addChild removeChild
2.改變對象的外觀 width height scaleX scaleY alpha color:RGB
3.對時間軸和舞臺的控制 gotoAndPlay gotoAndStop prerFrame nextFrame

具體方法

addChild()方法:可以將一個子實例添加到顯示對象容器中；

addChild()的使用方法：
DisplayObjectContainer.addChild(child:DisplayObject)

child:DisplayObject是作為DisplayObjectContainer實例的子對象添加到DisplayObject的實例，子對象被添加到該DisplayObjectContainer實例中的其他所有子對象的上面。
如果添加一個已將其他顯示對象容器作為父對象的子對象，則會從其他顯示對象容器的子列表中刪除該子對象。

addChildAt()方法:將子實例添加到對象容器中，可以指定顯示對象添加到容器中的層級；

addChildAt()方法的使用方法：
DisplayObjectContainer.addChildAt(child:DisplayObject,index:int);

 index:int—添加該子對象的索引位置，其值為0代表將顯示對象添加到顯示列表的最底層（可能被其上層的遮蓋）；
 index值大的實例位于上層

addChild()方法是按照對象加入的先后順序來確定對象在顯示列表中的層級位置，先加入的位于下層，后加入的位于上層；

使用addChildAt()方法將一個對象添加到某個已經有對象的索引位置，則該位置及其更高位置上的子對象都將上移一層

清除屏幕上的顯示對象用到以下兩種方法：

removeChild()方法：必須使用一個要移除的顯示對象的引用參數

DisplayObjectContainer.removeChild(child:DisplayObject);
其中child:DisplayObject是要刪除的對象名稱

removeChildAt()方法：刪除顯示列表中指定索引位置上的對象

DisplayObjectContainer.removeChildAt(index:int);
其中index:int為需要刪除的顯示對象的索引號

在ActionScript 3.0中，顯示對象容器中的每個子對象列表都在內部緩存為一個數組;
numChildren屬性:顯示對象容器的這個屬性表明容器中的子對象的個數。
在顯示對象容器的內部保留的顯示對象列表的順序決定了對象在屏幕上的顯示的屬性。索引值為0的對象位于列表的最底層，索引值為1的對象位于其上層，依次類推。這些位置編號間是沒有空缺的。

setChildIndex()方法：更改顯示對象列表中對象的索引號

DisplayObjectContainer.setChildIndex(child:DisplayObject,index:int)

其中child:DisplayObject為要更改索引號的對象實例，index:int為目標索引號

MovieClip對象常用的方法

play()、gotoAndPlay(scene,frame)
stop()、 gotoAndStop(scene,frame)
prevFrame()、nextFrame()

MovieClip對象常用的屬性

 currentFrame
 totalFrames
 currentLabel
 currentScene

五、第五章

1.移動 x\y

temp.x +=5;
temp.y +=5;

六、第六章(重點)

1.基本碰撞檢查 hitTestObejct hitTestPoint
2.多個對象的碰撞檢測 2層循環 隕石那題
3.特殊碰撞的檢測
4.什么是碰撞檢測？碰撞檢測在游戲當做有什么作用？各自的優勢是什么？哪些情況下需要使用哪種碰撞檢測

1、碰撞檢測的概念和方法

游戲中的碰撞檢測，簡單地說，就是判斷兩個顯示實例是否有在同一時刻，某個部分處在了同一位置上。
碰撞檢測就是判斷有可能發生碰撞的顯示實例，在某一時刻是否有重疊的情況發生。

Flash游戲中物體之間的碰撞檢測技術主要有兩大類：

• 1.基于包圍盒的碰撞檢測技術--hitTestObject方法；
• 2.基于像素的碰撞檢測技術--hitTestPoint方法

Flash中的DisplayObject類內置的兩種碰撞檢測方法:

• 1.hitTestObject方法用于判斷兩個顯示對象間是否發生了碰撞，是基于包圍盒的碰撞檢測技術；
• 2.hitTestPoint方法用于判斷某個點與顯示對象間是否發生了碰撞，是基于像素的碰撞檢測技術。

判斷movieclip1與movieclip2碰撞處理的代碼如下：

    if(movieclip1.hitTestObject(movieclip2))
    {
        //碰撞后的動作
    }

如果兩個影片發生了碰撞則返回true，并執行if語句塊的內容。這種碰撞檢測方法簡單，但其精確度較差。原因如下圖所示：從表面上看，很明顯應該只有兩個正方形碰到了

Paste_Image.png

Paste_Image.png

hitTestPoint方法中有兩個Number類型的參數，表示x,y坐標，用于定位點。根據顯示實例是否與某點相交，返回true或false。

最基本的形式如下：

objectA.hitTestPoint(x,y,shapeflag);
shapeflag:為true時，將在檢測碰撞時判斷對象中的可見圖形而非僅憑矩形邊界來判斷
可以在if語句中使用它來判斷碰撞為true時要執行的代碼，Flash只檢查給出的點是否在影片剪輯的矩形邊界內。

例如，判斷對象sprite是否與點（100,100）發生了碰撞：

    if(sprite.hitTestPoint(100,100)){
        //碰撞后的動作
    }

利用距離來檢測碰撞

根據需要設定兩個對象之間允許的最小距離，當對象間的距離小于這個距離時，就可以確定這2個對象是發生了碰撞了

計算屏幕上的對象objectA和objectB之間的距離：
>
var dx:Number=objectA.x-objectB.x
var dy:Number=objectA.y-objectB.y
var distance:Number=Math.sqrt(dx*dx+dy*dy)

當屏幕上存在著多個對象時，需要判斷它們彼此之間是否發生碰撞；
使用循環的嵌套，實現多個運動對象的碰撞檢測

//注意:
//外層循環是i= 0 ;i <numObjects-1;i++
//內層循環是j=i+1;j<numObjects;j++
>
for (var i:uint = 0; i < numObjects - 1; i++){
    var objectA = objects[i];   //從數組中獲取實例
    for (var j:uint = i + 1; j < numObjects; j++){
        var objectB = objects[j];     //同上
        if (objectA.hitTestObject(objectB)){
            statements;
          }
    }
}

九、第九章

1.關于音樂的加載 嵌入 Sound() UrlRequest() .play() .stop() .load() SoundChannel() SoundTramsform

創建一個新的Sound，并讓其自動加載該聲音文件：

var req:URLRequest = new URLRequest("click.mp3");
var s:Sound = new Sound(req);

上面兩條語句可以合為以下：

var s:Sound = new Sound(new URLRequest("click.mp3"));
//注意：加載的聲音文件要與源文件放在同一目錄中

s.load(req);
var channel = s.play(0,int.MAX_VALUE);  //play(startTime:Number=0,loops:int=0)
s.close();

var changeForm = new SoundTramsform()
channel.soundTransform = changeForm;
channel.positon
>
changeForm.volume = 0.5

st=>start: URLRequest類 加載
e=>end:SoundTransform類 控制
op1=>operation: Sound類(URLRequest類)
op2=>operation: SoundChannel = Sound類.play()方法
op3=>operation: SoundTransform類 = SoundChannel類.soundTransform屬性
st->op1->op2->op3->e

實驗題

實驗1：基本沒
實驗2: 2 (1) (4) 3(1) (3) (4)
實驗3：(一)2 (二) 1 2
實驗4：(一)2 (二)
實驗5：1 3

參考代碼

package  {
  import flash.display.MovieClip;

  public class shiyan2 extends MovieClip {

      public function shiyan2() {
          // constructor code
          trace("第一題");


          trace("答案1");
          var a:String = "12.3";
          var b:int = 4;
          trace(a+b);
          //加法int轉為了字符串 答案是12.34


          trace("答案2");
          var a:String = "12.3";
          trace("編譯無法通過");
          //var b:int =a;
          //trace(a+b);
          //string無法賦值給int類型


          trace("答案3");
          var a:String = "12.3";
          var b:int =int(a);
          trace(a+b);
          //int(a)=12 字符串a+b=12.312


          trace("答案4");
          var a:String = "12.3";
          var b:int =int(a);
          trace(b+10);
          //int(a)=12 a+b=22


          trace("常量的聲明和使用");
          const SECONDS:uint=60;
          trace("One minute = ", SECONDS,"seconds.");
          //SECONDS =61;
          //trace("One minute = ", SECONDS,"seconds.");
          trace("編譯無法通過");
          //常量const被定義無法修改


          trace("關系運算符及關系表達式的求值");
          var a1:Number = 100.1;
          var b1:Number = 100;
          trace("a>b is ",a1>b1);
          trace("ABC > abc is", "ABC">"abc");
          //變量值的比較和字符串值的比較不一樣


          trace("函數及其調用");
          function stuInfo(stu:Object):void{
              stu.name = "bb";
              trace(stu.name);
          }
          var myObj:Object = {name:"aa",age:18,dclass:"dm11"};
          stuInfo(myObj);
          trace(myObj.name);
          //函數內部作用域，執行stuInfo(myObj)時把myObj傳入了整個對象進去，并把其中的.name修改成了"bb",則先輸出bb。之后trace(myObj.name)輸出的是被修改之后的bb


          trace("程序的功能是求10個數中的最大值（順序、選擇、循環結構，簡單算法");
          var a2:Array = new Array(10);
          var temp:uint = 0;
          a2 = [12,32,56,48,15,35,78,19,65,68];
          for (var i:uint=0; i<a2.length-1; i++) {
              if (a2[i] > a2[i + 1]) {
                  temp = a2[i];
                  a2[i] = a2[i + 1];
                  a2[i + 1] = temp;
              }
          }
          trace("最大的元素值=",a2[a2.length-1]);
          //冒泡排序法 最大數換到最后一位


          trace("程序的功能是用選擇排序法將10個整數降序排序")
          var myArr:Array = new Array();
          myArr = [12,56,32,9,15,23,87,123,26,5,36,19];
          var k:int,temp2:int;
          trace("排序前",myArr);
          for (var j:uint=0;   j<myArr.length     ; j++) {
              k = j;
              for (var i:uint=j+1; i<myArr.length; i++) {
                  if (myArr[k] < myArr[i]) {
                      k=i ;
                  }
              }
              temp2 = myArr[j];
              myArr[j] = myArr[k];
              myArr[k] = temp2;
          }
          trace("排序后",myArr);
          //選擇排序法 找最小數字 放在最后一個位置


          trace("程序的功能是顯示XML集合中fname節點的內容");
          var myXML:XML = <users>
                <fname>二維動畫</fname>
                <fname>平面設計</fname>
                <fname>視頻編輯</fname>
                         </users>;
          for each (var i2 in  myXML.fname ){
              trace(i2);
          }
          //foreach遍歷myXML


          trace("程序的功能是定義一個數組和一個對象，并分別調用typeInfo函數，分別輸出數組中的各個元素、對象中的各個屬性");
          function typeInfo(obj2){
              if (obj2 is Array) {
                  //用is判斷參數類型
                  trace("數組中的元素包括：");
              }
              else if (obj2 is Object) {
                  trace("對象中的屬性包括：");
              }
              for (var i3 in obj2) {
                  //輸出參數中的各項內容
                  trace(i3,"=",obj2[i3]);
              }
          }
          //定義一個數組和一個對象，并分別調用函數
          var myArr:Array = [100,200,300];
          var myObj:Object = {name:"王明亮",age:30,height:180};
          typeInfo(myArr);
          typeInfo(myObj);
          //for ( go in All) go 迭代訪問變量



          trace("通過類的定義與繼承、接口的聲明與實現，輸出如下信息");
          /*
          //Pet.as中定義了一個寵物類Pet
          package{
              public class Pet{
                  public var master:String = "亨利";//master用于存儲主人的消息
                  public var name:String;           //name用于存儲寵物的名字
              }
          }
          //IPet.as中聲明了一個接口IPet
          package{
              public   interface  IPet{
                  function eat();
                  function sleep();
                  function run();
              }
          }
          //Dog.as中定義了一個繼承自Pet類的子類Dog，并實現接口IPet中的各個方法
          package{
              public class Dog  extend Pet implements IPet    {
                  public function Dog(name:String){
                      this.name = name;     //在構造函數中，傳遞參數為小狗的名字
                  }
                      //實現接口的eat方法
                  public function eat(){
                      trace(  this.master  +"喂" +   this.name   + "吃東西");
                  }
                      //實現接口的sleep方法
                  public function sleep(){
                      trace(this.name + "睡著了");
                  }
                      //實現接口的run方法
                  public function run(){
                      trace(this.name + "歡快地跳著");
                  }
              }
          }
          //inf.fla時間軸第一幀上添加代碼：
          var myDog:Dog =   new Dog("旺仔") ;
          myDog.run();
          myDog.eat();
          myDog.sleep();
          */

          trace("編寫一個計算從n1到n2累加和的函數mysum(n1:uint,n2:uint)，通過調用該函數，輸出從1到100的累加和（正確結果是5050）");

          function mysum(n1:uint,n2:uint){
              if(n2 == n1){
                  return n1;
              }else{
                  return mysum(n1,n2-1)+n2;
              }
          }
          trace(mysum(1,100));
          // 遞歸


          trace("編寫一個計算整數n的階乘的遞歸函數fac(n:uint):uint，通過調用該函數，輸出5的階乘（正確結果是120）");
          function fac(n:uint):uint{
              if(n==1){
                  return n;
              }else{
                  return n*fac(n-1);
              }
          }
          trace(fac(5));
          // 遞歸

      }
  }
}


package  {

  import flash.display.MovieClip;
  import flash.events.KeyboardEvent;
  import flash.events.Event;

  public class sy3 extends MovieClip {


      public function sy3() {

          stop();

          trace("kaishi")

          var frameNumber:Number;
          frame_N();
          //自定義函數，用于獲取當前幀
          stage.addEventListener(KeyboardEvent.KEY_DOWN, change_F); //偵聽鍵被按下事件

          function change_F(me:KeyboardEvent):void {

              switch (me) {
                   //判斷按下了什么鍵
                  case Keyboard.RIGHT :
                      if (frameNumber==this.totalFrames) { //是最后一幀？
                          this. gotoAndStop(1);     //是，跳轉到第一幀
                      }
                      else {
                          this.nextFrame();        //不是，跳轉到下一幀
                      }
                      frame_N();
                      break;
                  case Keyboard.LEFT :
                      if (frameNumber == 1) {  //是第一幀？
                          this.gotoAndStop(this.totalFrames);//到最后一幀
                      }
                      else {
                          this.prevFrame();        //跳轉到上一幀
                      }
              }
              frame_N();
          }

          function frame_N():void
          {
              frameNumber = this.currentFrame;           //獲取當前幀編號
              j_txt.text   = String(frameNumber);    //在文本框中顯示幀編號
          }


      }
  }

}

package  {
  import flash.display.MovieClip;
  import flash.events.Event;

  public class shiyan4 extends MovieClip {
      public function shiyan4() {

          /*
          var ball:MovieCircle= new MovieCircle() ;  //創建一個MoveCircle類的實例ball
          var di:int = 1;                    //控制左右移動方向變量，右為 1，左為 -1
          stage.addChild(ball) ;    //將實例ball添加到舞臺
          ball.x = 0;
          ball.y = Math.round(Math.random()*400) ; // 控制小球在窗口的高度（400）范圍內出現
          stage.addEventListener(Event.ENTER_FRAME , Move);  //幀頻事件
          function Move(e:Event):void{
              if (ball.x>( stage.stageWidth-ball.width)){   //小球右移超出舞臺邊界時
                  di = -1;
              }
              if (ball.x < 0) {
                  di = 1;
              }
              ball.x +=  5 * di;
          }
          */
          var di:Array = new Array();
          var mcs:Array = new Array();
          for(var i:uint=0; i<5; i++){
              di[i] = new int(1);
              mcs[i] = new MC();
              mcs[i].width = (i+1)*10;
              mcs[i].height = (i+1)*10;mcs[i].x = 0;
              mcs[i].y = 20 + (i+1)*mcs[i].height;
              stage.addChild(mcs[i]);  //將第i個實例添加到舞臺
          }
          stage.addEventListener(Event.ENTER_FRAME, Move);    //幀頻事件
          function Move(e:Event):void{
              for(i=0;i<5;i++){
                  if(mcs[i].x>(stage.stageWidth-mcs[i].width)) //實例右移超出舞臺邊界時
                      di[i]= -1;
                  if(mcs[i].x < 0 )
                      di[i]= 1;
                  mcs[i].x += 5*di[i];
              }
          }

      }
  }

}

***

## 教材

范例6-5
范例9-2 架子鼓
范例9-3 音樂的開關
P327 最后一行 改成channel = backSound.play(0,1000000);