#include "StageEditor_Event.h"
#include "StageEditor_TopButton.h"
#include "StageEditor_MoveButton.h"
#include "ToolLib.h"

// イベント配置リストの座標と幅と高さ
#define LIST_X          (4)
#define LIST_Y          (TOPBUTTON_Y + TOPBUTTON_H + TOOL_WINDOW_NAME_HEIGHT + 4)
#define LIST_W          (256)
#define LIST_H          (166)

// イベント操作ボタンの基準座標
#define BUTTONS1_X      (0)
#define BUTTONS1_Y      (6 + TOOL_SCROLLBAR_WIDTH + g_EEData.Button1Space.SpaceStart)

// イベントの操作ボタンを配置する範囲の高さ
#define BUTTONS1_H      (159)

// イベントの移動ボタンの配置座標
#define MOVE_X          (4)
#define MOVE_Y          (BUTTONS1_Y + 68)

// イベントタイプリストの座標と幅と高さ
#define TYPE_LIST_X     (LIST_X)
#define TYPE_LIST_Y     (LIST_Y + LIST_H + TOOL_WINDOW_NAME_HEIGHT + 4)
#define TYPE_LIST_W     (LIST_W)
#define TYPE_LIST_H     (80)

// イベント対象オブジェクトリストの座標と幅と高さ
#define OBJECT_LIST_X   (LIST_X)
#define OBJECT_LIST_Y   (TYPE_LIST_Y + TYPE_LIST_H + TOOL_WINDOW_NAME_HEIGHT + 4)
#define OBJECT_LIST_W   (LIST_W)
#define OBJECT_LIST_H   (160)

// イベント対象オブジェクトの追加・削除ボタンの配置座標
#define BUTTONS2_X      (0)
#define BUTTONS2_Y      (4 + TOOL_SCROLLBAR_WIDTH + g_EEData.Button2Space.SpaceStart)

// イベント対象オブジェクトの追加・削除ボタンを配置する範囲の高さ
#define BUTTONS2_H      (32)

// イベント配置編集情報
typedef struct _SEventEditData
{
    // 編集対象のイベントの配置番号
    int                 Target;

    // 編集対象のイベントが対象とするオブジェクトリスト内の編集対象番号
    int                 TargetObject;

    // スペース管理情報ハンドル
    int                 TSpaceManage;

    // 編集モード切替ボタン部分用のスペース情報
    SToolSpace          TopSpace;

    // イベント配置リスト表示用ウインドウのハンドル
    int                 ListTWindow;

    // イベント配置リストのハンドル
    int                 TList;

    // 操作ボタン部分用のスペース情報
    SToolSpace          Button1Space;

    // 配置イベント追加ボタンのハンドル
    int                 AddTButton;

    // 配置イベント削除ボタンのハンドル
    int                 DelTButton;

    // 配置イベントの数が０の場合に非表示にするボタンなどの表示状態情報ハンドル
    int                 ZeroTVisible;

    // 選択イベントのサイズ操作用ボタン
    int                 SizeXPlusTButton;
    int                 SizeXMinusTButton;
    int                 SizeYPlusTButton;
    int                 SizeYMinusTButton;
    int                 SizeZPlusTButton;
    int                 SizeZMinusTButton;

    // 選択イベントのＢＧＭ番号操作用ボタン
    int                 BGMPlusTButton;
    int                 BGMMinusTButton;

    // 選択イベントの移動ボタンの情報
    SMoveButtonData     MoveButton;

    // 選択イベントのイベントタイプ選択用リスト表示用ウインドウのハンドル
    int                 TypeListTWindow;

    // 選択イベントがイベントタイプ選択用リストのハンドル
    int                 TypeTList;

    // イベントタイプリストとイベントが対象とするオブジェクトリストの隙間用スペース情報
    SToolSpace          ObjectListSpace;

    // イベントが対象とするオブジェクトのリスト表示用ウインドウのハンドル
    int                 ObjectListTWindow;

    // イベントが対象とするオブジェクトのリストのハンドル
    int                 ObjectTList;

    // イベントが対象とするオブジェクトの追加・削除を行うボタン部分用のスペース情報
    SToolSpace          Button2Space;

    // イベントが対象とするオブジェクト追加ボタンのハンドル
    int                 AddObjectTButton;

    // イベントが対象とするオブジェクト削除ボタンのハンドル
    int                 DelObjectTButton;

    // イベントが対象とするオブジェクト番号操作用ボタンのハンドル
    int                 ObjTargetPlusTButton;
    int                 ObjTargetMinusTButton;
} SEventEditData;

// イベントタイプ名テーブル
const char *g_EventTypeName[ EStageEventType_Num ] =
{
    "ｷｬﾗ出現",
    "BGM変更",
};

// ＢＧＭ名テーブル
const char *g_BGMName[ EBGM_Num ] =
{
    "Stage0",
    "Stage1",
    "Title",
    "Boss",
    "GameOver",
    "StageClear",
    "AllStageClear",
};

// イベントタイプ毎の色のテーブル
int g_EventColor[ EStageEventType_Num ][ 3 ] =
{
    { 255,255,255 },        // EStageEventType_CharaAppear
    { 255,  0,255 },        // EStageEventType_BGM
};

SEventEditData g_EEData;

// イベントの配置情報を追加する
//     戻り値 : 処理が正常に終了したかどうか(true:正常に終了した  false:エラーが発生した)
static bool StageEditor_Event_Add( void );

// 選択中のイベントの配置情報を削除する
//     戻り値 : 処理が正常に終了したかどうか(true:正常に終了した  false:エラーが発生した)
static bool StageEditor_Event_Del( void );

// イベント配置リストをセットアップする
//     戻り値 : 処理が正常に終了したかどうか(true:正常に終了した  false:エラーが発生した)
static bool StageEditor_Event_SetupList( void );

// イベント配置情報編集処理の初期化を行う
//     戻り値 : 処理が正常に終了したかどうか(true:正常に終了した  false:エラーが発生した)
bool StageEditor_Event_Initialize( void )
{
    int i;
    int VisibleHandle;

    // スペース管理情報の作成
    g_EEData.TSpaceManage = ToolSpaceManage_Create( SCREEN_HEIGHT );
    if( g_EEData.TSpaceManage == -1 )
    {
        return false;
    }

    // 編集モード切替ボタン部分用のスペース情報を追加
    if( !ToolSpaceManage_AddSpace(
            g_EEData.TSpaceManage, &g_EEData.TopSpace, TOPSPACE, true ) )
    {
        return false;
    }

    // イベント配置リスト表示用ウインドウの作成
    g_EEData.ListTWindow = ToolWindow_Create( 
        g_EEData.TSpaceManage, false, true, false, "ｲﾍﾞﾝﾄ一覧",
        LIST_X, LIST_Y, LIST_W, LIST_H, LIST_W, LIST_H );
    if( g_EEData.ListTWindow == -1 )
    {
        return false;
    }

    // イベント配置リストの作成
    g_EEData.TList = ToolList_Create();
    if( g_EEData.TList == -1 )
    {
        return false;
    }

    // イベント配置リストを初期化
    ToolList_Initialize( g_EEData.TList, g_EEData.ListTWindow );

    // 操作ボタン部分用のスペース情報を追加
    if( !ToolSpaceManage_AddSpace(
            g_EEData.TSpaceManage, &g_EEData.Button1Space, BUTTONS1_H, true ) )
    {
        return false;
    }

    // 配置イベント追加ボタンの作成
    g_EEData.AddTButton           = ToolButton_Create(
        false, "ｲﾍﾞﾝﾄ追加", BUTTONS1_X +  4,  BUTTONS1_Y +  0, 70, BUTTON_H );
    if( g_EEData.AddTButton == -1 )
    {
        return false;
    }

    // 配置イベント削除ボタンの作成
    g_EEData.DelTButton           = ToolButton_Create(
        false, "ｲﾍﾞﾝﾄ削除", BUTTONS1_X + 74,  BUTTONS1_Y +  0, 70, BUTTON_H );
    if( g_EEData.DelTButton == -1 )
    {
        return false;
    }

    // 配置イベントの数が０の場合に非表示にするボタンなどの表示状態情報ハンドルの作成
    g_EEData.ZeroTVisible         = ToolVisible_Create();
    if( g_EEData.ZeroTVisible == -1 )
    {
        return false;
    }

    // 初期状態では表示状態にする
    ToolVisible_SetVisible( g_EEData.ZeroTVisible, true );


    // 選択イベントのサイズ操作用ボタンの作成
    g_EEData.SizeXPlusTButton     = ToolButton_Create(
        false, "ｻｲｽﾞX+",    BUTTONS1_X +  4,  BUTTONS1_Y + 24, 50, BUTTON_H );
    if( g_EEData.SizeXPlusTButton == -1 )
    {
        return false;
    }

    g_EEData.SizeXMinusTButton    = ToolButton_Create(
        false, "ｻｲｽﾞX-",    BUTTONS1_X +  4,  BUTTONS1_Y + 44, 50, BUTTON_H );
    if( g_EEData.SizeXMinusTButton == -1 )
    {
        return false;
    }

    g_EEData.SizeYPlusTButton     = ToolButton_Create(
        false, "ｻｲｽﾞY+",    BUTTONS1_X +  56, BUTTONS1_Y + 24, 50, BUTTON_H );
    if( g_EEData.SizeYPlusTButton == -1 )
    {
        return false;
    }

    g_EEData.SizeYMinusTButton    = ToolButton_Create(
        false, "ｻｲｽﾞY-",    BUTTONS1_X +  56, BUTTONS1_Y + 44, 50, BUTTON_H );
    if( g_EEData.SizeYMinusTButton == -1 )
    {
        return false;
    }

    g_EEData.SizeZPlusTButton     = ToolButton_Create(
        false, "ｻｲｽﾞZ+",    BUTTONS1_X + 108, BUTTONS1_Y + 24, 50, BUTTON_H );
    if( g_EEData.SizeZPlusTButton == -1 )
    {
        return false;
    }

    g_EEData.SizeZMinusTButton    = ToolButton_Create(
        false, "ｻｲｽﾞZ-",    BUTTONS1_X + 108, BUTTONS1_Y + 44, 50, BUTTON_H );
    if( g_EEData.SizeZMinusTButton == -1 )
    {
        return false;
    }


    // 選択イベントのＢＧＭ操作用ボタンの作成
    g_EEData.BGMPlusTButton       = ToolButton_Create(
        false, "BGM+",      BUTTONS1_X + 164, BUTTONS1_Y + 24, 50, BUTTON_H );
    if( g_EEData.BGMPlusTButton == -1 )
    {
        return false;
    }

    g_EEData.BGMMinusTButton      = ToolButton_Create(
        false, "BGM-",      BUTTONS1_X + 164, BUTTONS1_Y + 44, 50, BUTTON_H );
    if( g_EEData.BGMMinusTButton == -1 )
    {
        return false;
    }

    // 選択イベント移動用ボタン情報の初期化
    if( !MoveButton_Initialize( &g_EEData.MoveButton, MOVE_X, MOVE_Y ) )
    {
        return false;
    }

    // 選択イベントのイベントタイプ選択用リスト表示用ウインドウを作成
    g_EEData.TypeListTWindow = ToolWindow_Create( 
        g_EEData.TSpaceManage, false, true, false, "ｲﾍﾞﾝﾄﾀｲﾌﾟ一覧",
        TYPE_LIST_X, TYPE_LIST_Y, TYPE_LIST_W, TYPE_LIST_H, TYPE_LIST_W, TYPE_LIST_H );
    if( g_EEData.TypeListTWindow == -1 )
    {
        return false;
    }

    // 選択イベントのイベントタイプ選択用リストを作成
    g_EEData.TypeTList = ToolList_Create();
    if( g_EEData.TypeTList == -1 )
    {
        return false;
    }

    // イベントタイプリストの初期化
    ToolList_Initialize( g_EEData.TypeTList, g_EEData.TypeListTWindow );

    // イベントタイプをリストに追加
    for( i = 0; i < EStageEventType_Num; i++ )
    {
        if( !ToolList_AddObj( g_EEData.TypeTList, g_EventTypeName[ i ] ) )
        {
            return false;
        }
    }

    // イベントタイプリストとイベントが対象とするオブジェクトリストの
    // 隙間用スペース情報を追加
    if( !ToolSpaceManage_AddSpace(
            g_EEData.TSpaceManage, &g_EEData.ObjectListSpace, 4, true ) )
    {
        return false;
    }

    // イベントが対象とするオブジェクトのリスト表示用ウインドウの作成
    g_EEData.ObjectListTWindow = ToolWindow_Create( 
        g_EEData.TSpaceManage, false, true, false, "対象ｵﾌﾞｼﾞｪｸﾄ一覧",
        OBJECT_LIST_X, OBJECT_LIST_Y,
        OBJECT_LIST_W, OBJECT_LIST_H,
        OBJECT_LIST_W, OBJECT_LIST_H
    );
    if( g_EEData.ObjectListTWindow == -1 )
    {
        return false;
    }

    // イベントが対象とするオブジェクトのリストの作成
    g_EEData.ObjectTList = ToolList_Create();
    if( g_EEData.ObjectTList == -1 )
    {
        return false;
    }

    // イベントが対象とするオブジェクトのリストの初期化
    ToolList_Initialize( g_EEData.ObjectTList, g_EEData.ObjectListTWindow );

    // イベントが対象とするオブジェクトの追加・削除を行うボタン部分用のスペース情報を追加
    if( !ToolSpaceManage_AddSpace(
            g_EEData.TSpaceManage, &g_EEData.Button2Space, BUTTONS2_H, true ) )
    {
        return false;
    }

    // イベントが対象とするオブジェクト追加ボタンの作成
    g_EEData.AddObjectTButton      = ToolButton_Create(
        false, "ｵﾌﾞｼﾞｪ追加", BUTTONS2_X +  4,  BUTTONS2_Y +  0, 70, 20 );
    if( g_EEData.AddObjectTButton == -1 )
    {
        return false;
    }

    // イベントが対象とするオブジェクト削除ボタンの作成
    g_EEData.DelObjectTButton      = ToolButton_Create(
        false, "ｵﾌﾞｼﾞｪ削除", BUTTONS2_X + 74,  BUTTONS2_Y +  0, 70, 20 );
    if( g_EEData.DelObjectTButton == -1 )
    {
        return false;
    }

    // イベントが対象とするオブジェクト番号操作用ボタンの作成
    g_EEData.ObjTargetPlusTButton  = ToolButton_Create(
        false, "ｵﾌﾞｼﾞｪNO+",  BUTTONS2_X +  4,  BUTTONS2_Y + 24, 70, 20 );
    if( g_EEData.ObjTargetPlusTButton == -1 )
    {
        return false;
    }

    g_EEData.ObjTargetMinusTButton = ToolButton_Create(
        false, "ｵﾌﾞｼﾞｪNO-",  BUTTONS2_X + 74,  BUTTONS2_Y + 24, 70, 20 );
    if( g_EEData.ObjTargetMinusTButton == -1 )
    {
        return false;
    }

    // イベント配置編集処理用の表示状態情報ハンドルを取得
    VisibleHandle = StageEditor_TopButton_GetEditModeVisibleHandle( EEditMode_EventEdit);

    // イベント配置編集で使用するウインドウやボタンと表示状態情報ハンドルを関連付ける
    ToolWindow_SetVisibleHandle( g_EEData.ListTWindow,           VisibleHandle );
    ToolButton_SetVisibleHandle( g_EEData.AddTButton,            VisibleHandle );
    ToolButton_SetVisibleHandle( g_EEData.DelTButton,            VisibleHandle );
    ToolVisible_SetParent(       g_EEData.ZeroTVisible,          VisibleHandle );

    // 配置イベント数が０の場合に非表示にするボタンと表示状態情報ハンドルを関連付ける
    ToolButton_SetVisibleHandle( g_EEData.SizeXPlusTButton,      g_EEData.ZeroTVisible );
    ToolButton_SetVisibleHandle( g_EEData.SizeXMinusTButton,     g_EEData.ZeroTVisible );
    ToolButton_SetVisibleHandle( g_EEData.SizeYPlusTButton,      g_EEData.ZeroTVisible );
    ToolButton_SetVisibleHandle( g_EEData.SizeYMinusTButton,     g_EEData.ZeroTVisible );
    ToolButton_SetVisibleHandle( g_EEData.SizeZPlusTButton,      g_EEData.ZeroTVisible );
    ToolButton_SetVisibleHandle( g_EEData.SizeZMinusTButton,     g_EEData.ZeroTVisible );
    ToolButton_SetVisibleHandle( g_EEData.BGMPlusTButton,        g_EEData.ZeroTVisible );
    ToolButton_SetVisibleHandle( g_EEData.BGMMinusTButton,       g_EEData.ZeroTVisible );
    MoveButton_SetVisibleHandle( &g_EEData.MoveButton,           g_EEData.ZeroTVisible );
    ToolWindow_SetVisibleHandle( g_EEData.TypeListTWindow,       g_EEData.ZeroTVisible );
    ToolWindow_SetVisibleHandle( g_EEData.ObjectListTWindow,     g_EEData.ZeroTVisible );
    ToolButton_SetVisibleHandle( g_EEData.AddObjectTButton,      g_EEData.ZeroTVisible );
    ToolButton_SetVisibleHandle( g_EEData.DelObjectTButton,      g_EEData.ZeroTVisible );
    ToolButton_SetVisibleHandle( g_EEData.ObjTargetPlusTButton,  g_EEData.ZeroTVisible );
    ToolButton_SetVisibleHandle( g_EEData.ObjTargetMinusTButton, g_EEData.ZeroTVisible );

    // 正常終了
    return true;
}

// イベント配置情報編集処理のステージ読み込み後の初期化処理を行う
//     戻り値 : 処理が正常に終了したかどうか(true:正常に終了した  false:エラーが発生した)
bool StageEditor_Event_StageLoadInitialize( void )
{
    // 選択対象を初期化
    g_EEData.Target       = 0;

    // 編集対象のイベントが対象とするオブジェクトリスト内の編集対象番号を初期化
    g_EEData.TargetObject = 0;

    // イベント配置リストの情報を更新
    if( !StageEditor_Event_SetupList() )
    {
        return false;
    }

    // 正常終了
    return true;
}

// イベント配置情報編集処理で選択されているイベントの座標を取得する
//     戻り値 : 座標の取得に成功したかどうか( true:成功した  false:失敗した )
bool StagaEditor_Event_GetTargetPos(
    // 座標を代入する変数のアドレス
    VECTOR *TargetPos
)
{
    // 配置イベントが一つも無い場合は何もせずに終了
    if( g_StageData.Header.EventInfoNum == 0 )
    {
        return false;
    }

    *TargetPos = g_StageData.EventInfo[ g_EEData.Target ].Position;

    // 正常終了
    return true;
}

// イベントの配置情報を追加する
//     戻り値 : 処理が正常に終了したかどうか(true:正常に終了した  false:エラーが発生した)
static bool StageEditor_Event_Add( void )
{
    int              i;
    SStageEventInfo *EInfo;

    // イベント配置情報の数が既に最大数に達していたら何もせずに終了
    if( g_StageData.Header.EventInfoNum == STAGE_EVENT_MAX_NUM )
    {
        return true;
    }

    // 新しいイベント配置情報の初期化
    EInfo = &g_StageData.EventInfo[ g_StageData.Header.EventInfoNum ];
    EInfo->EventType  = EStageEventType_CharaAppear;
    EInfo->Position   = VAdd( g_SEData.Camera.Position,
                            VScale( g_SEData.Camera.Direction, ADD_UNIT_DISTANCE ) );
    EInfo->AreaSize.x = 400.0f;
    EInfo->AreaSize.y = 200.0f;
    EInfo->AreaSize.z = 400.0f;

    EInfo->ObjectNum = 0;
    for( i = 0; i < STAGE_EVENT_OBJECT_MAX_NUM; i++ )
    {
        EInfo->Object[ i ] = 0;
    }

    // 選択しているイベント配置情報を追加したイベント配置情報にする
    g_EEData.Target = g_StageData.Header.EventInfoNum;

    // 編集対象のイベントが対象とするオブジェクトリスト内の編集対象番号を初期化
    g_EEData.TargetObject = 0;

    // イベント配置情報の数を増やす
    g_StageData.Header.EventInfoNum++;

    // イベント配置リストの情報を更新
    if( !StageEditor_Event_SetupList() )
    {
        return false;
    }

    // 正常終了
    return true;
}

// 選択中のイベントの配置情報を削除する
//     戻り値 : 処理が正常に終了したかどうか(true:正常に終了した  false:エラーが発生した)
static bool StageEditor_Event_Del( void )
{
    // 配置されているオブジェクトの数が一つも無い場合は何もせずに終了
    if( g_StageData.Header.EventInfoNum == 0 )
    {
        return true;
    }

    // イベント配置情報の数を減らす
    g_StageData.Header.EventInfoNum--;

    // 削除処理後の選択対象のイベント配置情報を決定
    if( g_EEData.Target == g_StageData.Header.EventInfoNum )
    {
        g_EEData.Target = g_StageData.Header.EventInfoNum - 1;
        if( g_EEData.Target < 0 )
        {
            g_EEData.Target = 0;
        }
    }
    else
    {
        // 削除対象が配列の途中だった場合は情報を詰める
        memmove(
            &g_StageData.EventInfo[ g_EEData.Target ],
            &g_StageData.EventInfo[ g_EEData.Target + 1 ],
            sizeof( SStageEventInfo ) *
                ( g_StageData.Header.EventInfoNum - g_EEData.Target ) );
    }

    // 編集対象のイベントが対象とするオブジェクトリスト内の編集対象番号を初期化
    g_EEData.TargetObject = 0;

    // イベント配置リストの情報を更新
    if( !StageEditor_Event_SetupList() )
    {
        return false;
    }

    // 正常終了
    return true;
}

// イベント配置情報編集処理の状態推移処理を行う
//     戻り値 : 処理が正常に終了したかどうか(true:正常に終了した  false:エラーが発生した)
bool StageEditor_Event_Step( void )
{
    SStageEventInfo *EInfo;
    int              MouseClickEvent;
    bool             MouseClickEventEnable;
    float            MouseClickEventDistanceSq;
    int              i;
    float            DistanceSq;
    HITRESULT_LINE   HitResult;

    // 画面上に表示されているイベントがマウスカーソルでクリックされたかどうかを調べる
    if( ( g_SEData.Mouse.EdgeInput & MOUSE_INPUT_LEFT ) != 0 &&
          Tool_GetBaseRightX() < g_SEData.Mouse.ClickPosX )
    {
        // クリックされた座標で最も近いイベントを割り出す
        MouseClickEventEnable     = false;
        MouseClickEventDistanceSq = 0.0f;

        EInfo = g_StageData.EventInfo;
        for( i = 0; i < g_StageData.Header.EventInfoNum; i++, EInfo++ )
        {
            HitResult = HitCheck_Line_Cube(
                            g_SEData.Mouse.ClickPosNear,
                            g_SEData.Mouse.ClickPosFar,
                            VSub( EInfo->Position, VScale( EInfo->AreaSize, 0.5f ) ),
                            VAdd( EInfo->Position, VScale( EInfo->AreaSize, 0.5f ) )
            );

            // 当たっているか判定
            if( HitResult.HitFlag )
            {
                DistanceSq = VSquareSize( 
                                VSub( HitResult.Position,
                                            g_SEData.Mouse.ClickPosNear ) );

                // 当たっていたら、今まで当たったイベントが居なかったか、
                // 又は今まで当たったイベントより近かったら記録
                if( MouseClickEventEnable == false ||
                    DistanceSq < MouseClickEventDistanceSq )
                {
                    MouseClickEventEnable     = true;
                    MouseClickEvent           = i;
                    MouseClickEventDistanceSq = DistanceSq;
                }
            }
        }

        // イベントがクリックされた場合は編集対象のイベントの変更処理を行う
        if( MouseClickEventEnable )
        {
            g_EEData.Target = MouseClickEvent;

            // イベント配置リストの選択行を変更する
            ToolList_SetSelectIndex( g_EEData.TList, g_EEData.Target );

            // 選択しているイベントの情報を更新する
            StageEditor_Event_SetupInfo();
        }
    }

    // オブジェクト配置リストの状態が変化した場合は新しい編集対象を取得する
    if( ToolList_GetChange( g_EEData.TList, true ) )
    {
        g_EEData.Target = ToolList_GetSelectIndex( g_EEData.TList );

        // 選択しているイベントの情報を更新する
        StageEditor_Event_SetupInfo();

        // カメラを選択イベントが見える位置に移動する
        SetupTargetLookAtCamera();
    }

    // 配置イベント数が０かどうかで処理を分岐
    if( g_StageData.Header.EventInfoNum == 0 )
    {
        // 配置イベントの数が０の場合は配置イベントリスト以外を非表示にする
        ToolVisible_SetVisible( g_EEData.ZeroTVisible, false );
    }
    else
    {
        EInfo = &g_StageData.EventInfo[ g_EEData.Target ];

        // 配置イベントの数が０ではない場合はイベントリスト以外も表示する
        ToolVisible_SetVisible( g_EEData.ZeroTVisible, true );

        // 編集対象のイベントのイベントタイプがＢＧＭ変更かどうかで
        // 表示するボタンなどを変更
        if( EInfo->EventType == EStageEventType_BGM )
        {
            // イベントタイプがBGM変更の場合はBGM変更ボタン以外を非表示にする
            ToolWindow_SetVisible( g_EEData.ObjectListTWindow,     false );
            ToolButton_SetVisible( g_EEData.AddObjectTButton,      false );
            ToolButton_SetVisible( g_EEData.DelObjectTButton,      false );
            ToolButton_SetVisible( g_EEData.ObjTargetPlusTButton,  false );
            ToolButton_SetVisible( g_EEData.ObjTargetMinusTButton, false );

            ToolButton_SetVisible( g_EEData.BGMPlusTButton,        true );
            ToolButton_SetVisible( g_EEData.BGMMinusTButton,       true );
        }
        else
        {
            // イベントタイプがBGM変更以外の場合はBGM変更ボタンを非表示にして、
            // 且つイベントが対象とするオブジェクトが一つでもある場合は
            // イベントが対象とするオブジェクトの番号を変更するためのボタンを表示する
            ToolWindow_SetVisible( g_EEData.ObjectListTWindow,     true );
            ToolButton_SetVisible( g_EEData.AddObjectTButton,      true );
            ToolButton_SetVisible( g_EEData.DelObjectTButton,      true );

            if( g_StageData.EventInfo[ g_EEData.Target ].ObjectNum > 0 )
            {
                ToolButton_SetVisible( g_EEData.ObjTargetPlusTButton,  true );
                ToolButton_SetVisible( g_EEData.ObjTargetMinusTButton, true );
            }
            else
            {
                ToolButton_SetVisible( g_EEData.ObjTargetPlusTButton,  false );
                ToolButton_SetVisible( g_EEData.ObjTargetMinusTButton, false );
            }

            ToolButton_SetVisible( g_EEData.BGMPlusTButton,        false );
            ToolButton_SetVisible( g_EEData.BGMMinusTButton,       false );
        }

        // 配置イベントのイベントタイプのリストの選択行が変化した場合は
        // 配置イベントがイベントタイプを変更する
        if( ToolList_GetChange( g_EEData.TypeTList, true ) )
        {
            EInfo->EventType =
                ( EStageEventType )ToolList_GetSelectIndex( g_EEData.TypeTList );

            // イベント配置リストの情報を更新
            if( !StageEditor_Event_SetupList() )
            {
                return false;
            }
        }

        // 選択イベントのサイズ操作ボタンが押された場合はサイズを変更する
        if( ToolButton_GetRepeatBottom( g_EEData.SizeXPlusTButton ) )
        {
            EInfo->AreaSize.x += MOVE_BASE_SPEED;

            // イベント配置リストの情報を更新
            if( !StageEditor_Event_SetupList() )
            {
                return false;
            }
        }

        if( ToolButton_GetRepeatBottom( g_EEData.SizeXMinusTButton ) )
        {
            EInfo->AreaSize.x -= MOVE_BASE_SPEED;
            if( EInfo->AreaSize.x < 1.0f )
            {
                EInfo->AreaSize.x = 1.0f;
            }

            // イベント配置リストの情報を更新
            if( !StageEditor_Event_SetupList() )
            {
                return false;
            }
        }

        if( ToolButton_GetRepeatBottom( g_EEData.SizeYPlusTButton ) )
        {
            EInfo->AreaSize.y += MOVE_BASE_SPEED;

            // イベント配置リストの情報を更新
            if( !StageEditor_Event_SetupList() )
            {
                return false;
            }
        }

        if( ToolButton_GetRepeatBottom( g_EEData.SizeYMinusTButton ) )
        {
            EInfo->AreaSize.y -= MOVE_BASE_SPEED;
            if( EInfo->AreaSize.y < 1.0f )
            {
                EInfo->AreaSize.y = 1.0f;
            }

            // イベント配置リストの情報を更新
            if( !StageEditor_Event_SetupList() )
            {
                return false;
            }
        }

        if( ToolButton_GetRepeatBottom( g_EEData.SizeZPlusTButton ) )
        {
            EInfo->AreaSize.z += MOVE_BASE_SPEED;

            // イベント配置リストの情報を更新
            if( !StageEditor_Event_SetupList() )
            {
                return false;
            }
        }

        if( ToolButton_GetRepeatBottom( g_EEData.SizeZMinusTButton ) )
        {
            EInfo->AreaSize.z -= MOVE_BASE_SPEED;
            if( EInfo->AreaSize.z < 1.0f )
            {
                EInfo->AreaSize.z = 1.0f;
            }

            // イベント配置リストの情報を更新
            if( !StageEditor_Event_SetupList() )
            {
                return false;
            }
        }

        // 選択イベントのBGMを変更するボタンが押された場合はBGMを変更する
        if( ToolButton_GetClick( g_EEData.BGMPlusTButton, true ) )
        {
            if( EInfo->Bgm + 1 == EBGM_Num )
            {
                EInfo->Bgm = ( EBGM )0;
            }
            else
            {
                EInfo->Bgm = ( EBGM )( EInfo->Bgm + 1 );
            }

            // イベント配置リストの情報を更新
            if( !StageEditor_Event_SetupList() )
            {
                return false;
            }
        }

        if( ToolButton_GetClick( g_EEData.BGMMinusTButton, true ) )
        {
            if( EInfo->Bgm == 0 )
            {
                EInfo->Bgm = ( EBGM )( EBGM_Num - 1 );
            }
            else
            {
                EInfo->Bgm = ( EBGM )( EInfo->Bgm - 1 );
            }

            // イベント配置リストの情報を更新
            if( !StageEditor_Event_SetupList() )
            {
                return false;
            }
        }

        // 選択イベントの移動ボタンによる移動処理を行う
        if( MoveButton_Step(
                &g_EEData.MoveButton, &EInfo->Position,
                MOVE_BASE_SPEED * g_SEData.MoveSpeedF ) )
        {
            // イベント配置リストの情報を更新
            if( !StageEditor_Event_SetupList() )
            {
                return false;
            }
        }

        // 選択イベントが対象とするオブジェクトが一つでもあるかどうかで処理を分岐
        if( EInfo->ObjectNum > 0 )
        {
            // イベントが対象とするオブジェクトのリスト状態が変化した場合は
            // 新しい選択対象を取得する
            if( ToolList_GetChange( g_EEData.ObjectTList, true ) )
            {
                g_EEData.TargetObject = ToolList_GetSelectIndex( g_EEData.ObjectTList );
            }

            // イベントが対象とするオブジェクトの番号を操作するボタンが押された場合は
            // イベントが対象とするオブジェクトの番号を変更する
            if( ToolButton_GetClick( g_EEData.ObjTargetPlusTButton, true ) )
            {
                EInfo->Object[ g_EEData.TargetObject ]++;

                // イベントタイプによって処理を分岐
                switch( EInfo->EventType )
                {
                case EStageEventType_CharaAppear:
                    if( EInfo->Object[ g_EEData.TargetObject ] >=
                                                g_StageData.Header.CharaInfoNum )
                    {
                        EInfo->Object[ g_EEData.TargetObject ] = 0;
                    }
                    break;

                case EStageEventType_BGM:
                    break;
                }

                // 選択しているイベントの情報を更新する
                StageEditor_Event_SetupInfo();
            }

            if( ToolButton_GetClick( g_EEData.ObjTargetMinusTButton, true ) )
            {
                EInfo->Object[ g_EEData.TargetObject ]--;

                // イベントタイプによって処理を分岐
                switch( EInfo->EventType )
                {
                case EStageEventType_CharaAppear:
                    if( EInfo->Object[ g_EEData.TargetObject ] < 0 )
                    {
                        EInfo->Object[ g_EEData.TargetObject ] =
                                            g_StageData.Header.CharaInfoNum - 1;
                    }
                    break;

                case EStageEventType_BGM:
                    break;
                }

                // 選択しているイベントの情報を更新する
                StageEditor_Event_SetupInfo();
            }
        }

        // イベントが対象とするオブジェクトを追加するボタンが押されたら
        // イベントが対象とするオブジェクトを追加する
        if( ToolButton_GetClick( g_EEData.AddObjectTButton, true ) )
        {
            // 一つのイベントが対象とできるオブジェクトの最大数より少ない
            // 場合のみ追加可能
            if( EInfo->ObjectNum < STAGE_EVENT_OBJECT_MAX_NUM )
            {
                EInfo->Object[ EInfo->ObjectNum ] = 0;
                EInfo->ObjectNum++;

                // 選択しているイベントの情報を更新する
                StageEditor_Event_SetupInfo();
            }
        }

        // イベントが対象とするオブジェクトを削除するボタンが押されたら
        // 選択中のイベントが対象とするオブジェクトを削除する
        if( ToolButton_GetClick( g_EEData.DelObjectTButton, true ) )
        {
            // イベントが対象とするオブジェクトが一つでもある場合のみ処理をする
            if( EInfo->ObjectNum > 0 )
            {
                // イベントが対象とするオブジェクトの数を減らす
                EInfo->ObjectNum--;

                // 削除処理後の選択対象を決定
                if( g_EEData.TargetObject == EInfo->ObjectNum )
                {
                    g_EEData.TargetObject = EInfo->ObjectNum - 1;
                    if( g_EEData.TargetObject < 0 )
                    {
                        g_EEData.TargetObject = 0;
                    }
                }
                else
                {
                    // 削除対象が配列の途中だった場合は情報を詰める
                    memmove(
                        &EInfo->Object[ g_EEData.TargetObject ],
                        &EInfo->Object[ g_EEData.TargetObject + 1 ],
                        sizeof( int ) * ( EInfo->ObjectNum - g_EEData.TargetObject ) );
                }

                // 選択しているイベントの情報を更新する
                StageEditor_Event_SetupInfo();
            }
        }
    }

    // 配置イベントを追加するボタンが押されたら配置イベントを追加する
    if( ToolButton_GetClick( g_EEData.AddTButton, true ) )
    {
        StageEditor_Event_Add();
    }

    // 配置イベントを削除するボタンが押されたら選択されているイベントを削除する
    if( ToolButton_GetClick( g_EEData.DelTButton, true ) )
    {
        if( !StageEditor_Event_Del() )
        {
            return false;
        }
    }

    // 正常終了
    return true;
}

// イベント配置情報編集処理の描画処理を行う
void StageEditor_Event_Render( void )
{
    int              i;
    COLOR_F          EventColor;
    SStageEventInfo *EInfo;

    // ライティングなし、Ｚバッファを使用、Ｚバッファへの書き込みをＯＮにする
    SetUseLighting(      FALSE );
    SetUseZBufferFlag(   TRUE );
    SetWriteZBufferFlag( TRUE );

    // 配置イベントのボックスを描画
    EInfo = g_StageData.EventInfo;
    for( i = 0; i < g_StageData.Header.EventInfoNum; i++, EInfo++ )
    {
        EventColor.r = ( float )g_EventColor[ EInfo->EventType ][ 0 ];
        EventColor.g = ( float )g_EventColor[ EInfo->EventType ][ 1 ];
        EventColor.b = ( float )g_EventColor[ EInfo->EventType ][ 2 ];
        if( g_SEData.EditMode == EEditMode_EventEdit &&
            g_EEData.Target == i )
        {
            DrawCube3D( 
                VSub( EInfo->Position, VScale( EInfo->AreaSize, 0.5f ) ),
                VAdd( EInfo->Position, VScale( EInfo->AreaSize, 0.5f ) ),
                GetColor( ( int )( EventColor.r * g_SEData.BrinkColor.b ),
                          ( int )( EventColor.g * g_SEData.BrinkColor.b ),
                          ( int )( EventColor.b * g_SEData.BrinkColor.b ) ), 0, FALSE );
        }
        else
        {
            DrawCube3D( 
                VSub( EInfo->Position, VScale( EInfo->AreaSize, 0.5f ) ),
                VAdd( EInfo->Position, VScale( EInfo->AreaSize, 0.5f ) ),
                GetColor( ( int )EventColor.r,
                          ( int )EventColor.g,
                          ( int )EventColor.b ), 0, FALSE );
        }
    }

    // ライティングあり、Ｚバッファを使用しない、Ｚバッファへの書き込みをＯＦＦにする
    SetWriteZBufferFlag( FALSE );
    SetUseZBufferFlag(   FALSE );
    SetUseLighting(      TRUE );
}

// イベント配置リストをセットアップする
//     戻り値 : 処理が正常に終了したかどうか(true:正常に終了した  false:エラーが発生した)
static bool StageEditor_Event_SetupList( void )
{
    int i;
    SStageEventInfo *EInfo;

    // イベント配置リストを初期化する
    ToolList_Initialize( g_EEData.TList, g_EEData.ListTWindow );

    // 配置イベントが一つも無い場合はここで終了
    if( g_StageData.Header.EventInfoNum == 0 )
    {
        return true;
    }

    // 配置イベントの情報をリストに追加する
    EInfo = g_StageData.EventInfo;
    for( i = 0; i < g_StageData.Header.EventInfoNum; i++, EInfo++ )
    {
        // イベントタイプがＢＧＭ変更かどうかでリストに追加する文字列を変更
        if( EInfo->EventType == EStageEventType_BGM )
        {
            ToolList_AddObj(
                g_EEData.TList,
                "No:%d  Type:%s  BGM:%s  Pos:( %.1f, %.1f, %.1f )  Size:( %.1f, %.1f, %.1f )",
                i,
                g_EventTypeName[ EInfo->EventType ],
                g_BGMName[ EInfo->Bgm ],
                EInfo->Position.x,
                EInfo->Position.y,
                EInfo->Position.z,
                EInfo->AreaSize.x,
                EInfo->AreaSize.y,
                EInfo->AreaSize.z
            );
        }
        else
        {
            ToolList_AddObj(
                g_EEData.TList,
                "No:%d  Type:%s  Pos:( %.1f, %.1f, %.1f )  Size:( %.1f, %.1f, %.1f )",
                i,
                g_EventTypeName[ EInfo->EventType ],
                EInfo->Position.x,
                EInfo->Position.y,
                EInfo->Position.z,
                EInfo->AreaSize.x,
                EInfo->AreaSize.y,
                EInfo->AreaSize.z
            );
        }
    }

    // 編集対象のイベントの行を選択状態にする
    ToolList_SetSelectIndex( g_EEData.TList, g_EEData.Target );

    // 選択しているイベントの情報を更新する
    StageEditor_Event_SetupInfo();

    // 正常終了
    return true;
}

// イベントリストの選択対象をセットアップする
void StageEditor_Event_SetupInfo( void )
{
    int                    i;
    SStageEventInfo       *EInfo;
    SStageCharaInfo       *CInfo;

    // イベントが対象とするオブジェクトのリストを初期化する
    ToolList_Initialize( g_EEData.ObjectTList, g_EEData.ObjectListTWindow );

    // 配置イベントの数が０の場合はここで終了
    if( g_StageData.Header.EventInfoNum == 0 )
    {
        return;
    }

    EInfo = &g_StageData.EventInfo[ g_EEData.Target ];

    // 編集対象イベントのイベントタイプの行を選択状態にする
    ToolList_SetSelectIndex( g_EEData.TypeTList, EInfo->EventType );

    // イベントが対象とするオブジェクトの数が０か、
    // イベントタイプがＢＧＭ変更だった場合はここで終了
    if( EInfo->ObjectNum == 0 || EInfo->EventType == EStageEventType_BGM )
    {
        return;
    }

    // イベントタイプによってイベントが対象とするオブジェクトのリストに追加する
    // 情報を変更
    switch( EInfo->EventType )
    {
    case EStageEventType_CharaAppear:
        // キャラ出現イベントの場合
        for( i = 0; i < EInfo->ObjectNum; i++ )
        {
            if( EInfo->Object[ i ] >= g_StageData.Header.CharaInfoNum )
            {
                ToolList_AddObj(
                    g_EEData.ObjectTList,
                    "No:%d  ｷｬﾗNo:%d  Chara:----",
                    i,
                    EInfo->Object[ i ]
                );
            }
            else
            {
                CInfo = &g_StageData.CharaInfo[ EInfo->Object[ i ] ];
                ToolList_AddObj(
                    g_EEData.ObjectTList,
                    "No:%d  ｷｬﾗNo:%d  Chara:%s  Pos:( %.1f, %.1f, %.1f )",
                    i,
                    EInfo->Object[ i ],
                    CharaBase_GetInfo( CInfo->Chara )->Name,
                    CInfo->Position.x,
                    CInfo->Position.y,
                    CInfo->Position.z
                );
            }
        }
        break;

    case EStageEventType_BGM:
        break;
    }

    // イベントが対象とするオブジェクトリストの編集対象の行を選択状態にする
    ToolList_SetSelectIndex( g_EEData.ObjectTList, g_EEData.TargetObject );
}

// イベント情報から指定のイベントタイプのイベントを削除する
void StageEditor_Event_DelObject(
    // イベントタイプ
    EStageEventType EventType,

    // オブジェクト番号
    int ObjectIndex
)
{
    SStageEventInfo *EInfo;
    int              i;
    int              j;

    // 配置イベントの中から指定のイベントタイプ且つ指定のオブジェクト番号の
    // イベントが対象とするオブジェクトを削除する
    EInfo = g_StageData.EventInfo;
    for( i = 0; i < g_StageData.Header.EventInfoNum; i++, EInfo++ )
    {
        // イベントタイプが異なる場合は次のループへ
        if( EInfo->EventType != EventType )
        {
            continue;
        }

        // イベントが対象とするオブジェクトの数だけ繰り返し
        for( j = 0; j < EInfo->ObjectNum; j++ )
        {
            // 指定のイベントが見つかったら削除
            if( EInfo->Object[ j ] == ObjectIndex )
            {
                // イベントが対象とするオブジェクトの数を減らす
                EInfo->ObjectNum--;

                // 削除処理後の選択対象を決定
                if( j == EInfo->ObjectNum )
                {
                    if( g_EEData.Target == i &&
                        g_EEData.TargetObject == j )
                    {
                        g_EEData.TargetObject = EInfo->ObjectNum - 1;
                    }
                }
                else
                {
                    // 削除対象が配列の途中だった場合は情報を詰める
                    memmove(
                        &EInfo->Object[ j ],
                        &EInfo->Object[ j + 1 ],
                        sizeof( int ) * ( EInfo->ObjectNum - j ) );
                    j--;
                }
            }
            else
            // 削除されるオブジェクトよりも大きい番号だった場合は
            // オブジェクトの番号を１減らす
            if( EInfo->Object[ j ] > ObjectIndex )
            {
                EInfo->Object[ j ]--;
            }
        }
    }

    // 選択しているイベントの情報を更新する
    StageEditor_Event_SetupInfo();
}