Mercurial > hg > Members > koba > t_dandy

view state_task.cc @ 66:f27a6af6514c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
SchedRegister, game_task.h etc...
author tkaito
date Thu, 17 Feb 2011 10:56:56 +0900
parents 07bc996c8e49
children
line wrap: on
line source

#include <stdio.h>
#include <stdlib.h>
#include <SDL.h>
#include "SDL_opengl.h"
#include "object.h"
#include "Character.h"
#include "Character_state.h"
#include "tokuten.h"
#include "collision.h"
#include "bom.h"
#include "count2.h"
#include "sgoex.h"
#include "sankaku.h"
#include "tama.h"
#include "TaskManager.h"
#include "Func.h"
#include "property.h"
#include "ObjectType.h"
#include "debug_db.h"
#include "StateList.h"
#include "collision_task.h"


extern SpriteTable sptable[DEFOBJ];
extern TaskManager *tmanager;

CHARACTER *kyeenemyno = NULL;
CHARACTER *tekino0 = NULL;
CHARACTER *enemy_part1 = NULL;
CHARACTER *enemy_part2 = NULL;
CHARACTER *enemy_part3 = NULL;
CHARACTER *enemy_part4 = NULL;
CHARACTER *enemy_part5 = NULL;

HTaskPtr state_next;

//int tekino0;
int rinkx = 0;
int rinky = 0;
int rinkf1 = 0, rinkf2 = 0;
CHARACTER *asteroiddt[200];

int enemyfaste = 0;
int fastebos = 0;
int asteroidi = 0;

static int cpu_counter = SPE_1;

HTaskPtr
create_next()
{
    state_next = tmanager->create_task(Dummy);

    return state_next;
}

static CPU_TYPE
get_cpunum()
{
    cpu_counter += 1;
    if ((cpu_counter % SPE_5) == 1) {
	cpu_counter = SPE_1;
    }
    
    return (CPU_TYPE)cpu_counter;
}

static int
power_of_two(int input)
{
    int value = 1;

    while ( value < input ) {
	value <<= 1;
    }
    return value;
}


static void
ReDefSprite(int number, float w, float h, int color)
{
    SpriteTable *m = &sptable[number];
    m->w = w;
    m->h = h;
    m->color = (color & 32);
    m->mx = w / 2;
    m->my = h / 2;
    m->tex_w = power_of_two(m->w);
    m->tex_h = power_of_two(m->h);
}

void
printState(SchedTask *s, void *chara, void *arg)
{
    CHARACTER *p = (CHARACTER*)chara;
    printf("[ID]%d [COORD]x= %f  y= %f  vx= %f  vy= %f\n",
	   p->chara_id, p->x, p->y, p->vx, p->vy);

    state_check(p);
}

void
updateState(SchedTask *s, void *chara, void *arg)
{
    CHARACTER *p = (CHARACTER*)chara;

    state_check(p);
}


void
freeObject(SchedTask *s, void *chara, void *obj)
{
    free(obj);

    CHARACTER *p = (CHARACTER*)chara;

    state_check(p);
}


void
checkContainer(SchedTask *s, void *chara, void *obj)
{
    CHARACTER *p = (CHARACTER*)chara;
    ObjContainer *new_obj = (ObjContainerPtr)obj;

    if (new_obj->flag == true) {
	int length = new_obj->length;
	
	for (int i=0; i < length; i++) {
	    ObjDataPtr obj_data = &new_obj->data[i];
	    int type = obj_data->type;
	    
	    switch (type) {
	    case Boms:
		Bom(obj_data->x, obj_data->y);
		break;
	    case Tama:
		Puttama(obj_data->tama_type, obj_data->x, obj_data->y);
		break;
	    case Enemy: {
		int task_num = GetStateNum(obj_data->task);
		Putenemy(obj_data->charano, obj_data->x, obj_data->y,
			 obj_data->vx, obj_data->vy, state_list[task_num].state);
		break;
	    }
	    case Def:
		ReDefSprite(obj_data->number, obj_data->w, obj_data->h, obj_data->color);
		break;
	    case DefEx:
		DefSpriteEx(obj_data->number, obj_data->middlex, obj_data->middley);
		break;
	    case Put:
		PutSprite(obj_data->zorder, obj_data->x, obj_data->y, obj_data->number);
		break;
	    case PutEx:
		PutSpriteEx(obj_data->number, obj_data->x, obj_data->y,
			    obj_data->scalex, obj_data->scaley, obj_data->angle);
		break;
	    }
	}
    }

    state_check(p);
    free(new_obj);
}


CHARACTER*
SimpleStateTask(CHARACTER *p)
{
    int task_num = p->state_task;
    HTaskPtr state_task = tmanager->create_task(task_num);

    state_task->set_inData(0, p, sizeof(CHARACTER));

    state_task->set_outData(0, p, sizeof(CHARACTER));

    state_task->set_post(updateState, (void*)p, NULL);

#ifndef PPE_ONLY
    state_task->set_cpu(get_cpunum());
#else
    state_task->set_cpu(CPU_PPE);
#endif

    state_next->wait_for(state_task);
    state_task->spawn();

    return p;
}


CHARACTER*
sendRandomTask(CHARACTER *p)
{
    int task_num = p->state_task;
    HTaskPtr state_task = tmanager->create_task(task_num);

    uint32 rand1 = random();
    uint32 rand2 = random();
    uint32 rand3 = random();
    uint32 rand4 = random();
    
    state_task->set_param(0, (memaddr)rand1);
    state_task->set_param(1, (memaddr)rand2);
    state_task->set_param(2, (memaddr)rand3);
    state_task->set_param(3, (memaddr)rand4);

    state_task->set_inData(0, p, sizeof(CHARACTER));

    state_task->set_outData(0, p, sizeof(CHARACTER));

    state_task->set_post(updateState, (void*)p, NULL);

#ifndef PPE_ONLY
    state_task->set_cpu(get_cpunum());
#else
    state_task->set_cpu(CPU_PPE);
#endif

    state_next->wait_for(state_task);
    state_task->spawn();

    return p;
}


CHARACTER*
withJikiTask(CHARACTER *p)
{
    int task_num = p->state_task;
    HTaskPtr state_task = tmanager->create_task(task_num);

    state_task->set_inData(0, p, sizeof(CHARACTER));
    state_task->set_inData(1, &jiki, sizeof(player));

    state_task->set_outData(0, p, sizeof(CHARACTER));

    state_task->set_post(updateState, (void*)p, NULL);

#ifndef PPE_ONLY
    state_task->set_cpu(get_cpunum());
#else
    state_task->set_cpu(CPU_PPE);
#endif

    state_next->wait_for(state_task);
    state_task->spawn();
    
    return p;
}


CHARACTER*
sendContainerTask(CHARACTER *p)
{
    int task_num = p->state_task;
    int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
    HTaskPtr state_task = tmanager->create_task(task_num);
    ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
    obj->flag = false;
    obj->length = 0;

    state_task->set_inData(0, p, sizeof(CHARACTER));

    state_task->set_outData(0, p, sizeof(CHARACTER));
    state_task->set_outData(1, obj, 0);

    state_task->set_post(checkContainer, (void*)p, (void*)obj);

#ifndef PPE_ONLY
    state_task->set_cpu(get_cpunum());
#else
    state_task->set_cpu(CPU_PPE);
#endif

    state_next->wait_for(state_task);
    state_task->spawn();
    
    return p;
}


CHARACTER*
JikiContainerTask(CHARACTER *p)
{
    int task_num = p->state_task;
    int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
    HTaskPtr state_task = tmanager->create_task(task_num);
    ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
    obj->flag = false;
    obj->length = 0;

    state_task->set_inData(0, p, sizeof(CHARACTER));
    state_task->set_inData(1, &jiki, sizeof(player));

    state_task->set_outData(0, p, sizeof(CHARACTER));
    state_task->set_outData(1, obj, 0);

    state_task->set_post(checkContainer, (void*)p, (void*)obj);    

#ifndef PPE_ONLY
    state_task->set_cpu(get_cpunum());
#else
    state_task->set_cpu(CPU_PPE);
#endif

    state_next->wait_for(state_task);
    state_task->spawn();
    
    return p;
}


CHARACTER*
AsteroidTask(CHARACTER *p)
{
    asteroiddt[asteroidi] = p;

    int task_num = Asteroid;
    HTaskPtr state_task = tmanager->create_task(task_num);
    
    state_task->set_param(0, (memaddr)asteroidi);
    
    state_task->set_inData(0, p, sizeof(CHARACTER));
    
    state_task->set_outData(0, p, sizeof(CHARACTER));
    
    int array_size = sizeof(CHARACTER)*asteroidi;
    if (array_size > 0) {
	CHARACTER *asteroid_array = (CHARACTER*)tmanager->allocate(array_size);
	for (int i = 0; i < asteroidi; i++) {
	    asteroid_array[i] = *asteroiddt[i];
	}
	state_task->set_inData(1, asteroid_array, array_size);
	state_task->set_post(freeObject, (void*)p, (void*)asteroid_array);
    } else {
	state_task->set_post(updateState, (void*)p, NULL);
    }

#ifndef PPE_ONLY
    state_task->set_cpu(get_cpunum());
#else
    state_task->set_cpu(CPU_PPE);
#endif

    state_next->wait_for(state_task);
    state_task->spawn();
    
    asteroidi++;
    return p;
}


CHARACTER*
Boss1Task1(CHARACTER *p)
{
    int task_num = p->state_task;
    int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
    HTaskPtr state_task = tmanager->create_task(task_num);
    ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
    obj->flag = false;
    obj->length = 0;

    state_task->set_inData(0, p, sizeof(CHARACTER));
    state_task->set_inData(1, &count, sizeof(int));

    state_task->set_outData(0, p, sizeof(CHARACTER));
    state_task->set_outData(1, &count, sizeof(int));
    state_task->set_outData(2, obj, 0);

    state_task->set_post(checkContainer, (void*)p, (void*)obj);

#ifndef PPE_ONLY    
    state_task->set_cpu(get_cpunum());
#else
    state_task->set_cpu(CPU_PPE);
#endif

    state_next->wait_for(state_task);
    state_task->spawn();
    
    return p;
}


CHARACTER*
Boss1Task2(CHARACTER *p)
{
    int task_num = p->state_task;
    int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
    HTaskPtr state_task = tmanager->create_task(task_num);
    ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
    obj->flag = false;
    obj->length = 0;
    
    state_task->set_inData(0, p, sizeof(CHARACTER));
    state_task->set_inData(1, &count, sizeof(int));
    
    state_task->set_outData(0, p, sizeof(CHARACTER));
    state_task->set_outData(1, &count, sizeof(int));
    state_task->set_outData(2, &rinkx, sizeof(int));
    state_task->set_outData(3, &rinky, sizeof(int));
    state_task->set_outData(4, obj, 0);

    state_task->set_post(checkContainer, (void*)p, (void*)obj);

#ifndef PPE_ONLY
    state_task->set_cpu(get_cpunum());
#else
    state_task->set_cpu(CPU_PPE);
#endif

    state_next->wait_for(state_task);
    state_task->spawn();
    
    return p;
}


CHARACTER*
Boss1Task3(CHARACTER *p)
{
    int task_num = p->state_task;
    HTaskPtr state_task = tmanager->create_task(task_num);
    
    state_task->set_param(0, (memaddr)rinkx);
    state_task->set_param(1, (memaddr)rinky);

    state_task->set_inData(0, p, sizeof(CHARACTER));
    
    state_task->set_outData(0, p, sizeof(CHARACTER));
    state_task->set_outData(1, &rinkf1, sizeof(int));
    
    state_task->set_post(updateState, (void*)p, NULL);

#ifndef PPE_ONLY
    state_task->set_cpu(get_cpunum());
#else
    state_task->set_cpu(CPU_PPE);
#endif


    state_next->wait_for(state_task);
    state_task->spawn();
    
    return p;
}


CHARACTER*
Boss1Task4(CHARACTER *p)
{
    int task_num = p->state_task;
    int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
    HTaskPtr state_task = tmanager->create_task(task_num);
    ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
    obj->flag = false;
    obj->length = 0;
    
    state_task->set_param(0, (memaddr)rinkf1);
    state_task->set_param(1, (memaddr)count);

    state_task->set_inData(0, p, sizeof(CHARACTER));
    
    state_task->set_outData(0, p, sizeof(CHARACTER));
    state_task->set_outData(1, &count, sizeof(int));
    state_task->set_outData(2, obj, 0);

    state_task->set_post(checkContainer, (void*)p, (void*)obj);

#ifndef PPE_ONLY
    state_task->set_cpu(get_cpunum());
#else
    state_task->set_cpu(CPU_PPE);
#endif

    state_next->wait_for(state_task);
    state_task->spawn();
    
    return p;
}


CHARACTER*
Boss1Task5(CHARACTER *p)
{
    int task_num = p->state_task;
    int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
    HTaskPtr state_task = tmanager->create_task(task_num);
    ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
    obj->flag = false;
    obj->length = 0;

    state_task->set_param(0, (memaddr)fastebos);
    state_task->set_param(1, (memaddr)count);
    state_task->set_param(2, (memaddr)rinkx);
    state_task->set_param(3, (memaddr)rinky);
    
    state_task->set_inData(0, p, sizeof(CHARACTER));
    state_task->set_inData(1, &jiki, sizeof(player));
    
    state_task->set_outData(0, p, sizeof(CHARACTER));
    state_task->set_outData(1, &count, sizeof(int));
    state_task->set_outData(2, &fastebos, sizeof(int));
    state_task->set_outData(3, &rinkx, sizeof(int));
    state_task->set_outData(4, &rinky, sizeof(int));
    state_task->set_outData(5, &rinkf2, sizeof(int));
    state_task->set_outData(6, obj, 0);

    state_task->set_post(checkContainer, (void*)p, (void*)obj);

#ifndef PPE_ONLY
    state_task->set_cpu(get_cpunum());
#else
    state_task->set_cpu(CPU_PPE);
#endif

    state_next->wait_for(state_task);
    state_task->spawn();
    
    return p;
}


CHARACTER*
Boss1Task6(CHARACTER *p)
{
    int task_num = p->state_task;
    int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
    HTaskPtr state_task = tmanager->create_task(task_num);
    ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
    obj->flag = false;
    obj->length = 0;
    
    state_task->set_param(0, (memaddr)rinkx);
    state_task->set_param(1, (memaddr)rinky);
    state_task->set_param(2, (memaddr)filpcount);
    state_task->set_param(3, (memaddr)tekino0->f);
    state_task->set_param(4, (memaddr)count);

    state_task->set_inData(0, p, sizeof(CHARACTER));
    state_task->set_inData(1, &rinkf2, sizeof(int));
    
    state_task->set_outData(0, p, sizeof(CHARACTER));
    state_task->set_outData(1, &count, sizeof(int));
    state_task->set_outData(2, obj, 0);

    state_task->set_post(checkContainer, (void*)p, (void*)obj);

#ifndef PPE_ONLY
    state_task->set_cpu(get_cpunum());
#else
    state_task->set_cpu(CPU_PPE);
#endif

    state_next->wait_for(state_task);
    state_task->spawn();
    
    return p;
}


CHARACTER*
Boss2Task1(CHARACTER *p)
{
    int task_num = p->state_task;
    int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
    HTaskPtr state_task = tmanager->create_task(task_num);
    ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
    obj->flag = false;
    obj->length = 0;

    state_task->set_param(0, (memaddr)enemy_part1->f);
    state_task->set_param(1, (memaddr)enemy_part5->f);
    state_task->set_param(2, (memaddr)random());

    state_task->set_inData(0, p, sizeof(CHARACTER));
    state_task->set_inData(1, &count, sizeof(int));
    
    state_task->set_outData(0, p, sizeof(CHARACTER));
    state_task->set_outData(1, &count, sizeof(int));
    state_task->set_outData(2, &rinkx, sizeof(int));
    state_task->set_outData(3, &rinkf1, sizeof(int));
    state_task->set_outData(4, obj, 0);

    state_task->set_post(checkContainer, (void*)p, (void*)obj);

#ifndef PPE_ONLY
    state_task->set_cpu(get_cpunum());
#else
    state_task->set_cpu(CPU_PPE);
#endif

    state_next->wait_for(state_task);
    state_task->spawn();
    
    return p;
}


CHARACTER*
Boss2Task2(CHARACTER *p)
{
    int task_num = p->state_task;
    int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
    HTaskPtr state_task = tmanager->create_task(task_num);
    ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
    obj->flag = false;
    obj->length = 0;

    state_task->set_inData(0, p, sizeof(CHARACTER));
    state_task->set_inData(1, &count, sizeof(int));
    state_task->set_inData(2, &rinkx, sizeof(int));
    state_task->set_inData(3, &rinkf1, sizeof(int));
    
    state_task->set_outData(0, p, sizeof(CHARACTER));
    state_task->set_outData(1, &count, sizeof(int));
    state_task->set_outData(2, &rinkx, sizeof(int));
    state_task->set_outData(3, &rinkf1, sizeof(int));
    state_task->set_outData(4, obj, 0);

    state_task->set_post(checkContainer, (void*)p, (void*)obj);

#ifndef PPE_ONLY
    state_task->set_cpu(get_cpunum());
#else
    state_task->set_cpu(CPU_PPE);
#endif

    state_next->wait_for(state_task);
    state_task->spawn();
    
    return p;
}

static int myrand = 1;

CHARACTER*
Boss2Task3(CHARACTER *p)
{
    int task_num = p->state_task;
    int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
    HTaskPtr state_task = tmanager->create_task(task_num);
    ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
    obj->flag = false;
    obj->length = 0;

    state_task->set_param(0, (memaddr)myrand);

    state_task->set_inData(0, p, sizeof(CHARACTER));
    state_task->set_inData(1, &count, sizeof(int));
    
    state_task->set_outData(0, p, sizeof(CHARACTER));
    state_task->set_outData(1, &count, sizeof(int));
    state_task->set_outData(2, obj, 0);

    state_task->set_post(checkContainer, (void*)p, (void*)obj);

#ifndef PPE_ONLY
    state_task->set_cpu(get_cpunum());
#else
    state_task->set_cpu(CPU_PPE);
#endif

    state_next->wait_for(state_task);
    state_task->spawn();
    
    return p;
}


CHARACTER*
Boss2Task4(CHARACTER *p, int num1, int num2)
{
    int task_num = p->state_task;
    int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
    HTaskPtr state_task = tmanager->create_task(task_num);
    ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
    obj->flag = false;
    obj->length = 0;

    state_task->set_param(0, (memaddr)enemy_part1->f);
    state_task->set_param(1, (memaddr)enemy_part2->f);
    state_task->set_param(2, (memaddr)enemy_part3->f);
    state_task->set_param(3, (memaddr)enemy_part4->f);
    state_task->set_param(4, (memaddr)enemystate[num1].charano);
    state_task->set_param(5, (memaddr)enemystate[num2].charano);

    state_task->set_inData(0, p, sizeof(CHARACTER));
    state_task->set_inData(1, kyeenemyno, sizeof(CHARACTER));
    state_task->set_inData(2, &count, sizeof(int));
    state_task->set_inData(3, &rinkf1, sizeof(int));
    
    state_task->set_outData(0, p, sizeof(CHARACTER));
    state_task->set_outData(1, &count, sizeof(int));
    state_task->set_outData(2, obj, 0);

    state_task->set_post(checkContainer, (void*)p, (void*)obj);

#ifndef PPE_ONLY
    state_task->set_cpu(get_cpunum());
#else
    state_task->set_cpu(CPU_PPE);
#endif

    state_next->wait_for(state_task);
    state_task->spawn();
    
    return p;
}


CHARACTER*
Boss2Task5(CHARACTER *p, int num1, int num2)
{
    int task_num = p->state_task;
    int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
    HTaskPtr state_task = tmanager->create_task(task_num);
    ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
    obj->flag = false;
    obj->length = 0;

    state_task->set_param(0, (memaddr)enemy_part1->f);
    state_task->set_param(1, (memaddr)enemy_part2->f);
    state_task->set_param(2, (memaddr)enemy_part3->f);
    state_task->set_param(3, (memaddr)enemy_part4->f);
    state_task->set_param(4, (memaddr)enemystate[num1].charano);
    state_task->set_param(5, (memaddr)enemystate[num2].charano);

    state_task->set_inData(0, p, sizeof(CHARACTER));
    state_task->set_inData(1, kyeenemyno, sizeof(CHARACTER));
    state_task->set_inData(3, &rinkf2, sizeof(int));
    
    state_task->set_outData(0, p, sizeof(CHARACTER));
    state_task->set_outData(1, obj, 0);

    state_task->set_post(checkContainer, (void*)p, (void*)obj);

#ifndef PPE_ONLY
    state_task->set_cpu(get_cpunum());
#else
    state_task->set_cpu(CPU_PPE);
#endif

    state_next->wait_for(state_task);
    state_task->spawn();
    
    return p;
}


CHARACTER*
Boss4Task(CHARACTER *p)
{
    kyeenemyno = p;

    int task_num = p->state_task;
    int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
    HTaskPtr state_task = tmanager->create_task(task_num);
    ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
    obj->flag = false;
    obj->length = 0;

    state_task->set_param(0, (memaddr)myrand);

    state_task->set_inData(0, p, sizeof(CHARACTER));
    state_task->set_inData(1, &count, sizeof(int));
    
    state_task->set_outData(0, p, sizeof(CHARACTER));
    state_task->set_outData(1, &count, sizeof(int));
    state_task->set_outData(2, obj, 0);

    state_task->set_post(checkContainer, (void*)p, (void*)obj);

#ifndef PPE_ONLY
    state_task->set_cpu(get_cpunum());
#else
    state_task->set_cpu(CPU_PPE);
#endif

    state_next->wait_for(state_task);
    state_task->spawn();
    
    return p;
}


CHARACTER*
Boss5Task1(CHARACTER *p)
{
    int task_num = p->state_task;
    int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
    HTaskPtr state_task = tmanager->create_task(task_num);
    ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
    obj->flag = false;
    obj->length = 0;

    state_task->set_param(0, (memaddr)random());
    state_task->set_param(1, (memaddr)random());

    state_task->set_inData(0, p, sizeof(CHARACTER));
    state_task->set_inData(1, &jiki, sizeof(player));

    state_task->set_outData(0, p, sizeof(CHARACTER));
    state_task->set_outData(1, obj, 0);

    state_task->set_post(checkContainer, (void*)p, (void*)obj);    

#ifndef PPE_ONLY
    state_task->set_cpu(get_cpunum());
#else
    state_task->set_cpu(CPU_PPE);
#endif

    state_next->wait_for(state_task);
    state_task->spawn();
    
    return p;
}


CHARACTER*
Boss5Task2(CHARACTER *p)
{
    int task_num = p->state_task;
    int obj_size = sizeof(ObjContainer)+sizeof(ObjData)*DATA_LENGTH;
    HTaskPtr state_task = tmanager->create_task(task_num);
    ObjContainerPtr obj = (ObjContainerPtr)tmanager->allocate(obj_size);
    obj->flag = false;
    obj->length = 0;

    state_task->set_param(0, (memaddr)random());
    state_task->set_param(1, (memaddr)random());
    state_task->set_param(2, (memaddr)random());
    state_task->set_param(3, (memaddr)random());

    state_task->set_inData(0, p, sizeof(CHARACTER));
    state_task->set_inData(1, &jiki, sizeof(player));

    state_task->set_outData(0, p, sizeof(CHARACTER));
    state_task->set_outData(1, obj, 0);

    state_task->set_post(checkContainer, (void*)p, (void*)obj);    

#ifndef PPE_ONLY
    state_task->set_cpu(get_cpunum());
#else
    state_task->set_cpu(CPU_PPE);
#endif

    state_next->wait_for(state_task);
    state_task->spawn();
    
    return p;
}


CHARACTER*
noaction(CHARACTER *p)
{
  return p;
}


CHARACTER*
delete_chara(CHARACTER *p)
{
    CHARACTER *parent = p;
    p->f = FALSE;
    p->state = noaction;
    p->collision = noaction;
    return parent;
}


CHARACTER*
chara_state0(CHARACTER *p)
{
    p->state_task = State0;
    return SimpleStateTask(p);
}


CHARACTER*
chara_state1(CHARACTER *p)
{
    p->state_task = State1;
    return SimpleStateTask(p);
}


CHARACTER*
chara_state2(CHARACTER *p)
{
    p->state_task = State2;
    return SimpleStateTask(p);
}


CHARACTER*
chara_state3(CHARACTER *p)
{
    p->state_task = State3;
    return sendContainerTask(p);
}


CHARACTER*
chara_state4(CHARACTER *p)
{
    p->state_task = State4;
    return withJikiTask(p);
}


CHARACTER*
chara_state5(CHARACTER *p)
{
    p->state_task = State5;
    return withJikiTask(p);
}


CHARACTER*
chara_state6(CHARACTER *p)
{
    p->state_task = State6;
    return withJikiTask(p);
}


CHARACTER*
chara_state7(CHARACTER *p)
{
    p->state_task = State7;
    return sendContainerTask(p);
}


// state1 boss patern
CHARACTER*
chara_state8(CHARACTER *p)
{
    tekino0 = p;
    kyeenemyno = p;

    p->state_task = State8;
    return Boss1Task1(p);
}


CHARACTER*
chara_state9(CHARACTER *p)
{
    p->state_task = State9;    
    return Boss1Task2(p);
}


CHARACTER*
chara_state10(CHARACTER *p)
{
    p->state_task =State10;
    return Boss1Task3(p);
}


CHARACTER*
chara_state11(CHARACTER *p)
{
    p->state_task = State11;
    return Boss1Task4(p);
}


CHARACTER*
chara_state12(CHARACTER *p)
{
    p->state_task = State12;
    return Boss1Task5(p);
}


CHARACTER*
chara_state13(CHARACTER *p)
{
    p->state_task = State13;
    return Boss1Task6(p);
}


CHARACTER*
chara_state20(CHARACTER *p)
{
    p->state_task = State20;
    return SimpleStateTask(p);
}


CHARACTER*
chara_state21(CHARACTER *p)
{
    p->state_task = State21;
    return SimpleStateTask(p);
}
//ここまでgetate boss


CHARACTER*
chara_state22(CHARACTER *p)
{
    p->state_task = State22;
    return sendRandomTask(p);
}


CHARACTER*
chara_state23(CHARACTER *p)
{
    p->state_task = State23;
    return AsteroidTask(p);
}


CHARACTER*
chara_state24(CHARACTER *p)
{
    kyeenemyno = p;
    tekino0 = 0;
    enemy_part1 = p->next;
    enemy_part2 = enemy_part1->next;
    enemy_part3 = enemy_part2->next;
    enemy_part4 = enemy_part3->next;
    enemy_part5 = enemy_part4->next;
    rinkx = 0;
    rinky = 0;
    rinkf1 = 0;
    rinkf2 = 0;
    p->state_task = State25;

    state_check(p);
    return p;
}

CHARACTER*
chara_state25(CHARACTER *p)
{
    p->state_task = State25;
    return Boss2Task1(p);
}

CHARACTER*
chara_state26(CHARACTER *p)
{
    p->state_task = State26;
    return Boss2Task2(p);
}

CHARACTER*
chara_state27(CHARACTER *p) //rocket punch
{
    p->state_task = State27;
    return Boss2Task2(p);
}
CHARACTER*
chara_state28(CHARACTER *p)
{
    p->state_task = State28;
//if many rand
    return Boss2Task3(p);
}


CHARACTER*
chara_state29(CHARACTER *p)
{
    p->state_task = State29;
    return sendContainerTask(p);
}


CHARACTER*
chara_state30(CHARACTER *p)
{
    p->state_task = State30;
    return SimpleStateTask(p);
}


CHARACTER*
chara_state31(CHARACTER *p) //right hand
{
    p->state_task = State31;
    return Boss2Task4(p, 0, 0);
}


CHARACTER*
chara_state32(CHARACTER *p) //left hand
{
    p->state_task = State32;
    return Boss2Task4(p, 14, 20);
}



CHARACTER*
chara_state33(CHARACTER *p) // right shoulder
{
    p->state_task = State33;
    return Boss2Task4(p, 11, 19);
}


CHARACTER*
chara_state34(CHARACTER *p) //left shoulder
{
    p->state_task = State34;
    return Boss2Task4(p, 12, 21);
}


CHARACTER*
chara_state35(CHARACTER *p) // bust
{
    p->state_task = State35;
    return Boss2Task4(p, 15, 16);
}



CHARACTER*
chara_state40(CHARACTER *p) //arm vulkan
{
    p->state_task = State40;
    return Boss2Task4(p, 0, 0);
}


CHARACTER*
chara_state41(CHARACTER *p) //left arm up arm vulkan
{
    p->state_task = State41;
//if rand
    return Boss2Task5(p, 0, 0);
}


CHARACTER*
chara_state400(CHARACTER *p)
{
    p->state_task = State400;
    return SimpleStateTask(p);
}


CHARACTER*
chara_state401(CHARACTER *p)
{
    p->state_task = State401;
    return JikiContainerTask(p);
}


CHARACTER*
chara_state402(CHARACTER *p)
{
    p->state_task = State402;
    return JikiContainerTask(p);
}


CHARACTER*
chara_state410(CHARACTER *p)
{
    kyeenemyno = p;
    p->state_task = State411;
    
    state_check(p);
    return p;
}


CHARACTER*
chara_state411(CHARACTER *p)
{
    p->state_task = State411;
    return JikiContainerTask(p);
}


CHARACTER*
chara_state500(CHARACTER *p)
{
    p->state_task = State500;
    return Boss4Task(p);
}


CHARACTER*
chara_state501(CHARACTER *p)
{
    p->state_task = State501;
    return sendContainerTask(p);
}


CHARACTER*
chara_state600(CHARACTER *p)
{
  kyeenemyno = p;
  p->state_task = State600;
  return sendContainerTask(p);
}


CHARACTER*
chara_state601(CHARACTER *p)
{
    p->state_task = State601;
    return Boss5Task1(p);
}


CHARACTER*
chara_state602(CHARACTER *p)
{
    p->state_task = State602;
    return Boss5Task2(p);
}