プログラマ専用SNS ミクプラ

コード:

#pragma once
#include "mover.h"
#include <cassert>

class Shot;

extern TaskList ship_list;
extern TaskList shot_list;

class Ship : public Mover{
public:
	Ship(	int graphics_,
			Vector r_ = Vector(0,0),
			Vector v_ = Vector(0,0),
			double collision_radius_ = 5,
			double speed_fast_ = 1,
			double speed_slow_ = 0.5,
			unsigned int life_ = 2,
			unsigned int power_ = 1,
			unsigned int bomb_ = 2 ,
			void (*generate_shot_func_) (Mover*) = 0)
		: Mover(graphics_ , r_ , v_,Circle(0.2)) ,
		speed_fast(15.0) , speed_slow(speed_slow_) , life(life_) , power(power_) , bomb(bomb_), generate_shot_func(generate_shot_func_){
		//リストの末尾に挿入
		this->next = ship_list.begin_used;
		this->prev = ship_list.begin_used->prev;
		ship_list.begin_used->prev->next = this;
		ship_list.begin_used->prev = this;

		this->task_list = &ship_list;
		//基本的にコントローラー制御
		operate_move_func = 0;
	}
	void *operator new(size_t s){
		return ship_list.fetch();
	}
	void operator delete(void* p){
		ship_list.erase(p);
	}

	void move() override;
	virtual void shot();
	void (*generate_shot_func) (Mover*);

protected:
	double speed_fast;
	double speed_slow;
	unsigned int life;
	unsigned int power;
	unsigned int bomb;
};

class Shot : public Mover{
public:
	Shot(	int graphics_,
			Vector r_ = Vector(0,0),
			Vector v_ = Vector(0,80),
			double collision_radius_ = 5,
			unsigned int power_ = 1
		)
		: Mover(graphics_ , r_ , v_,Circle(collision_radius_)) ,
		power(power_) {
		//リストの末尾に挿入
		this->next = shot_list.begin_used;
		this->prev = shot_list.begin_used->prev;
		shot_list.begin_used->prev->next = this;
		shot_list.begin_used->prev = this;

		this->task_list = &shot_list;
		//TODO : 引数に取れるようにする
		operate_move_func = 0;
	}
	
	void* operator new(size_t s){
		return shot_list.fetch();
	}
	void operator delete(void* p){
		shot_list.erase(p);
	}
	virtual void move() override;

	double power;
};

コード:

#pragma once

class Task;
class TaskList;
class TaskIter;

class Task{
	friend class TaskList;
	friend class TaskIter;
	friend class Ship;
	friend class Shot;

public:
	Task(){}
	Task(TaskList &tl);

protected:
	Task* next;
	Task* prev;
	TaskList* task_list;

	void* operator new(size_t t){};
	void  operator delete(void* p){};
};

class TaskList{
	friend class TaskIter;
	friend class Ship;
	friend class Shot;

public:
	//freeは単方向リスト usedは双方向リスト
	TaskList(size_t,unsigned int);

	Task* fetch();
	void erase(void*);

	unsigned int size();
	bool empty();
	bool full();

	void move();
	void draw();

protected:
	Task* at(unsigned int);
	Task* begin_free;
	Task* begin_used;
	
	unsigned int max_task_num;
	unsigned int task_num;
	size_t size_task;
};

class TaskIter{
public:
	TaskIter(const TaskList*);
	
	const TaskList* operating_task_list;

	Task* target();
	Task* next();
	Task* prev();
	void proceed();
	bool end();
protected:
	Task* target_task;
};

コード:

#include "Task.h"
#include "Mover.h"
#include "DxLib.h"
#include <cassert>

TaskList::TaskList(size_t size_, unsigned int num_){
	max_task_num=num_;
	task_num=0;
	size_task=size_;

	//動的に確保 charは1バイトなのでそのまま乗算
	char* buffer = new char[size_*(num_+2)];
	
	//初期状態 : begin_used , begin_free , フリータスク , フリータスク , フリータスク ...
	begin_free=(Task*)(buffer+size_);
	begin_used=(Task*)buffer;

	//リスト構造を作る
	//freeは単方向リスト usedは双方向リスト

	//usedリストはこのような状態が空であることをあらわす
	begin_used->next = begin_used;
	begin_used->prev = begin_used;
	begin_used->task_list = (TaskList*)buffer;
	
	//freeリストは単方向なのでprevはさわらなくてよいはず（？）
	for(unsigned int i=1; i<num_+1; i++){
		Task* free_task = at(i);
		free_task->next = at(i+1);
		free_task->task_list = (TaskList*)buffer;
	}
	at(num_+1)->next = at(1);
	at(num_+1)->task_list = (TaskList*)buffer;
}

Task* TaskList::fetch(){
	//満杯ならエラー
	assert( !full() );
	
	//freeの先頭から抜き出し
	Task* rtn_task = begin_free->next;
	begin_free->next = begin_free->next->next;
	
	//used末尾への挿入はコンストラクタで行う

	rtn_task->task_list = this;
	
	task_num++;

	return rtn_task;
}

void TaskList::erase(void* useless_task){
	//空ならエラー
	assert(task_num>0);

	Task* p=static_cast<Task*>(useless_task);
	//usedから削除
	p->prev->next = p->next;
	p->next->prev = p->prev;

	//free先頭へ挿入
	p->next = begin_free->next;
	begin_free->next = p;

	task_num--;

	return;
}

Task* TaskList::at(unsigned int n){
	return (Task*)( (char*)begin_used + n*size_task );
}

unsigned int TaskList::size(){
	return task_num;
}

bool TaskList::full(){
	return begin_free->next == begin_free;
}

bool TaskList::empty(){
	return begin_used->next == begin_used;
}

void TaskList::move(){
	for(TaskIter ti(this); !ti.end(); ti.proceed() ){
		Mover* p = static_cast<Mover*>(ti.target());
		p->move();
	}
}

void TaskList::draw(){
	for(TaskIter ti(this); !ti.end(); ti.proceed() ){
		Mover* p = static_cast<Mover*>(ti.target());
		p->draw();
	}
}

TaskIter::TaskIter(const TaskList* tl){
	operating_task_list = tl;
	target_task = tl->begin_used->next;
}

Task* TaskIter::target(){
	return target_task;
}

Task* TaskIter::next(){
	return target_task->next;
}

void TaskIter::proceed(){
	target_task = next();
}

bool TaskIter::end(){
	return target_task == operating_task_list->begin_used;
}