Question

我正在为学习目的编码，遇到了一个明显无法解决的问题。

我将首先向您介绍我的代码。

这是我的Main class中的一个函数

public function confirm_route(evt:MouseEvent):void
    {
        var route = new Route(this, Airport.return_ROUTE);
        Airport.return_ROUTE = new Array();
    }

“Airport.return_ROUTE”只是一个数组，其起源与问题无关。在Main类中，我还声明了我的background var，并把它作为一个公共静态var。由于我需要从另外两个类访问这个背景，我没有看到另一个选项，只是声明它，即使我认为它不理想。我将在稍后的解释中回到这一点。

My Route类在屏幕上动态创建新的航班，因此得名。这基于Airport.return_ROUTE数组。我需要将这些航班作为孩子添加到后台，这是在Main类中创建的，如上所述。这也是我在调用路由函数时添加“this”作为参数的原因。

this.myparent = pMyParent;

我使用上面的行来引用主实例。由于Route实例不是movieclip，我想这是能够引用它的唯一方法。

如前所述，Route实例动态创建new_flights。

new_flight = new Flight(infoarray);
myparent.background_mc.addChild(new_flight);

这显然是为了将new_flight添加到后台movieclip。

让我们看看Flight类，因为这是问题发生的地方。

由于我的游戏概念，我需要在它到达背景动画片段上的某个点时删除new_flight。

此功能旨在完成这项工作：

private function deleteThis():void
    {
        this.parent.removeChild(this)
    }

这会返回TypeError: Error #1009: Cannot access a property or method of a null object reference.

我真的不明白如何以不同的方式解决这个问题。

编辑：根据要求，我将发布我的路线课程。

package 
{

import flash.events.TimerEvent;
import flash.utils.Timer;
import flash.display.MovieClip;
import flash.events.Event;
import flash.events.EventDispatcher;
import Main;

public class Route extends Main
{
    public var income:Number;
    public var routePoints:Array;
    private var routeTimer:Timer;
    private var new_flight:Flight;

    // ------------

    private var myparent:Main;

    public function Route(route_array:Array, pMyParent)
    {
        this.myparent = pMyParent;
        this.routePoints = route_array;
        routeTimer = new Timer(2000);// 2 second
        routeTimer.addEventListener(TimerEvent.TIMER, route_function);
        routeTimer.start();
    }
    private function route_function(event:TimerEvent):void
    {
        for (var counter:uint = 0; counter < routePoints.length - 1; counter ++)
        {   
            trace("Coords: ", routePoints[counter][0],routePoints[counter][1],routePoints[counter + 1][0],routePoints[counter + 1][1]);
            new_flight = new Flight(myparent, routePoints[counter][0],routePoints[counter][1],routePoints[counter + 1][0],routePoints[counter + 1][1]);
            myparent.bg_image.addChild(new_flight);

            var checkTimer:Timer = new Timer(15);// 1 second
            checkTimer.addEventListener(TimerEvent.TIMER, check_function);
            checkTimer.start();

            function check_function(event:TimerEvent):void
            {
                if (new_flight.finished = true)
                {
                    checkTimer.stop();
                }
            }
        }
    }

}

}

编辑2：发布航班类

package 
{
import flash.display.MovieClip;
import flash.display.Sprite;
import flash.events.MouseEvent;
import flash.events.Event;
import flash.display.SimpleButton;
import flash.display.Stage;
import flash.events.TimerEvent;
import flash.utils.Timer;
import fl.controls.Button;
import flash.display.DisplayObject;

public class Flight extends MovieClip

{
    public static var speed:uint = 1
    public var finished:Boolean = false;

    protected var absvector:Number;
    protected var vector:Array;
    protected var myTimer:Timer;
    //protected var parentContainer:MovieClip;

    protected var utgangspunkt_x;
    protected var utgangspunkt_y;
    protected var destinasjon_x;
    protected var destinasjon_y;

    protected var vector_x;
    protected var vector_y;

    private var myparent:Main

    public function Flight(pMyParent, utgangspunkt_x, utgangspunkt_y, destinasjon_x, destinasjon_y):void
    {
        addEventListener(Event.ADDED_TO_STAGE, init);           

        this.myparent = pMyParent;

        this.utgangspunkt_x = utgangspunkt_x;
        this.utgangspunkt_y = utgangspunkt_y;

        this.x = utgangspunkt_x;
        this.y = utgangspunkt_y;    

        this.destinasjon_x = destinasjon_x + 10;
        this.destinasjon_y = destinasjon_y + 10;

        this.vector_x = Math.abs(this.destinasjon_x-this.utgangspunkt_x);
        this.vector_y = Math.abs(this.destinasjon_y-this.utgangspunkt_y);

        this.height = 20;
        this.width = 20;
    }

    public function init(evt:Event):void
    {
        removeEventListener(Event.ADDED_TO_STAGE, init);
        trace(this.parent)
        trace("---------------------------------------------------")
        if (utgangspunkt_x < destinasjon_x)
        {
            this.rotation = -(Math.atan((utgangspunkt_y-destinasjon_y)/(destinasjon_x-utgangspunkt_x)))/(Math.PI)*180;
        }
        else
        {
            this.rotation = 180-(Math.atan((utgangspunkt_y-destinasjon_y)/(destinasjon_x-utgangspunkt_x)))/(Math.PI)*180;
        }

        absvector = Math.sqrt(Math.pow((destinasjon_x - utgangspunkt_x),2) + Math.pow((utgangspunkt_y - destinasjon_y),2));
        vector = [(destinasjon_x - utgangspunkt_x) / absvector,(utgangspunkt_y - destinasjon_y) / absvector];

        stage.addEventListener(Event.ENTER_FRAME, movement)
    }

    private function movement(evt:Event):void
    {
        if (this.vector_x > this.vector_y)
        {
            if (destinasjon_x>utgangspunkt_x)
            {
                if (this.x < destinasjon_x)
                {
                    this.x +=  speed*vector[0];
                    this.y -=  speed*vector[1];
                }
                else
                {
                    deleteThis()
                }
            }
            else if (destinasjon_x<utgangspunkt_x)
            {
                if (this.x > destinasjon_x)
                {
                    this.x +=  speed*vector[0];
                    this.y -=  speed*vector[1];
                }
                else
                {
                    deleteThis()
                }
            }
        }
        else
        {
            if (destinasjon_y>utgangspunkt_y)
            {
                if (this.y < destinasjon_y)
                {
                    this.x +=  speed*vector[0];
                    this.y -=  speed*vector[1];
                }
                else
                {
                    deleteThis()
                }
            }
            else if (destinasjon_y<utgangspunkt_y)
            {
                if (this.y > destinasjon_y)
                {
                    this.x +=  speed*vector[    0];
                    this.y -=  speed*vector[1];
                }
                else
                {
                    deleteThis()
                }
            }
        }
    }

    private function deleteThis():void
    {
        finished = true;
        this.parent.removeChild(this)
    }
}
}

Answer 1

我怀疑你的deleteThis方法不止一次被调用。这可以解释为什么你有[对象图像]然后没有... 这种方法是通过某种事件调用的吗？如果是这种情况，请确保不会多次触发此事件。

动作脚本3：从父母那里删除孩子的麻烦

1 个答案: