Mercurial > hg > Members > koba > t_dandy

comparison state_task.cc @ 25:ee4c488d48a3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
add Puttama func.
author koba <koba@cr.ie.u-ryukyu.ac.jp>
date Mon, 27 Dec 2010 02:35:06 +0900
parents 5f1abbe03b9a
children c4210c1053e8
comparison
equal deleted inserted replaced
24:86c6b3bdc763 25:ee4c488d48a3
60 { 60 {
61 SetTaskState(DELETE_CHARA, delete_chara); 61 SetTaskState(DELETE_CHARA, delete_chara);
62 SetTaskState(STATE0, chara_state0); 62 SetTaskState(STATE0, chara_state0);
63 SetTaskState(STATE1, chara_state1); 63 SetTaskState(STATE1, chara_state1);
64 SetTaskState(STATE2, chara_state2); 64 SetTaskState(STATE2, chara_state2);
65 // SetTaskState(STATE3, chara_state3); 65 SetTaskState(STATE3, chara_state3);
66 SetTaskState(STATE4, chara_state4); 66 SetTaskState(STATE4, chara_state4);
67 SetTaskState(STATE5, chara_state5); 67 SetTaskState(STATE5, chara_state5);
68 SetTaskState(STATE6, chara_state6); 68 SetTaskState(STATE6, chara_state6);
69 #if 0 69 #if 0
70 SetTaskState(STATE7, chara_state7); 70 SetTaskState(STATE7, chara_state7);
112 112
113 int num = GetStateNum(p->task); 113 int num = GetStateNum(p->task);
114 p=state_list[num](p); 114 p=state_list[num](p);
115 } 115 }
116 116
117 void
118 checkSingleTama(SchedTask *s, void *chara, void *tama)
119 {
120 CHARACTER *p = (CHARACTER*)chara;
121 TamaContainer *new_tama = (TamaContainerPtr)tama;
122
123 if (new_tama->flag == true) {
124 Puttama(new_tama->type, new_tama->x, new_tama->y);
125 }
126
127 int num = GetStateNum(p->task);
128 p=state_list[num](p);
129 free(new_tama);
130 }
131
117 CHARACTER* 132 CHARACTER*
118 SimpleStateTask(CHARACTER *p) 133 SimpleStateTask(CHARACTER *p)
119 { 134 {
120 int task_num = p->task; 135 int task_num = p->task;
121 HTaskPtr state_task = tmanager->create_task(task_num); 136 HTaskPtr state_task = tmanager->create_task(task_num);
122 137
123 state_task->add_inData(p, sizeof(CHARACTER)); 138 state_task->add_inData(p, sizeof(CHARACTER));
139
124 state_task->add_outData(p, sizeof(CHARACTER)); 140 state_task->add_outData(p, sizeof(CHARACTER));
141
125 state_task->set_post(updateState, (void*)p, NULL); 142 state_task->set_post(updateState, (void*)p, NULL);
126 143
127 state_task->set_cpu(SPE_ANY); 144 state_task->set_cpu(SPE_ANY);
128 state_task->spawn(); 145 state_task->spawn();
129 146
133 CHARACTER* 150 CHARACTER*
134 withJikiTask(CHARACTER *p) 151 withJikiTask(CHARACTER *p)
135 { 152 {
136 int task_num = p->task; 153 int task_num = p->task;
137 HTaskPtr state_task = tmanager->create_task(task_num); 154 HTaskPtr state_task = tmanager->create_task(task_num);
138 155
139 state_task->add_inData(p, sizeof(CHARACTER)); 156 state_task->add_inData(p, sizeof(CHARACTER));
140 state_task->add_inData(&jiki, sizeof(player)); 157 state_task->add_inData(&jiki, sizeof(player));
158
141 state_task->add_outData(p, sizeof(CHARACTER)); 159 state_task->add_outData(p, sizeof(CHARACTER));
160
142 state_task->set_post(updateState, (void*)p, NULL); 161 state_task->set_post(updateState, (void*)p, NULL);
143 162
144 state_task->set_cpu(SPE_ANY); 163 state_task->set_cpu(SPE_ANY);
145 state_task->spawn(); 164 state_task->spawn();
146 165
147 return p; 166 return p;
148 } 167 }
149 168
150 CHARACTER* 169 CHARACTER*
170 putTamaTask1(CHARACTER *p)
171 {
172 int task_num = p->task;
173 HTaskPtr state_task = tmanager->create_task(task_num);
174 TamaContainerPtr tama = (TamaContainerPtr)tmanager->allocate(sizeof(TamaContainer));
175
176 state_task->add_inData(p, sizeof(CHARACTER));
177 state_task->add_inData(tama, sizeof(TamaContainer));
178
179 state_task->add_outData(p, sizeof(CHARACTER));
180 state_task->add_outData(tama, sizeof(TamaContainer));
181
182 state_task->set_post(checkSingleTama, (void*)p, (void*)tama);
183
184 state_task->set_cpu(SPE_ANY);
185 state_task->spawn();
186
187 return p;
188 }
189
190 CHARACTER*
151 noaction(CHARACTER *p) 191 noaction(CHARACTER *p)
152 { 192 {
153 p->state = noaction; 193 p->state = noaction;
154 return p; 194 return p;
155 } 195 }
181 { 221 {
182 p->task = STATE2; 222 p->task = STATE2;
183 return SimpleStateTask(p); 223 return SimpleStateTask(p);
184 } 224 }
185 225
186 #if 0 226
187 CHARACTER * chara_state3(CHARACTER *p) 227 CHARACTER * chara_state3(CHARACTER *p)
188 { 228 {
189 p->x += p->vx; 229 p->task = STATE3;
190 p->y += p->vy; 230 return putTamaTask1(p);
191 if((p->dt1 == 60) || 231 }
192 (p->dt1 == 90) ||
193 (p->dt1 == 30))
194 {
195 Puttama(0, p->x, p->y);
196 }
197 p->dt1++;
198 p->state = chara_state3;
199 //PutSprite(count, p->x, p->y, p->charano);
200 return p;
201 }
202 #endif
203 232
204 CHARACTER * chara_state4(CHARACTER *p) 233 CHARACTER * chara_state4(CHARACTER *p)
205 { 234 {
206 p->task = STATE4; 235 p->task = STATE4;
207 return withJikiTask(p); 236 return withJikiTask(p);