LOCKYOUで学ぶ

function add(m, n) {
	if(m == 0) {
		return n;
	} else {
		return add(m-1, n)+1;
	}
};
console.log(add(4,6)); // 10

console.log(add(4,6));              console.log(   10   );
              │                                   ↑
              ↓                                   └───┐
function add(4, 6) {                function add(4, 6) {   │
    if(4 == 0) {                        if(4 == 0) {       │
        return n;                           return n;      │
    } else {                            } else {           │
        return add(4-1, 6)+1;               return     ９     +1;
    }                 │                }              ↑
};            ┌───┘            };                 └─┐
              ↓                                           │
function add(3, 6) {                function add(3, 6) {   │
    if(3 == 0) {                        if(3 == 0) {       │
        return n;                           return n;      │
    } else {                            } else {           │
        return add(3-1, 6)+1;               return     ８     +1;
    }                 │                }              ↑
};            ┌───┘            };                 └─┐
              ↓                                           │
function add(2, 6) {                function add(2, 6) {   │
    if(2 == 0) {                        if(2 == 0) {       │
        return n;                           return n;      │
    } else {                            } else {           │
        return add(2-1, 6)+1;               return     ７     +1;
    }                 │                }              ↑
};            ┌───┘            };                 └─┐
              ↓                                           │
function add(1, 6) {                function add(1, 6) {   │
    if(1 == 0) {                        if(1 == 0) {       │
        return n;                           return n;      │
    } else {                            } else {           │
        return add(1-1, 6)+1;               return     ６     +1;
    }                 │                }              ↑
};            ┌───┘            };                 │
              ↓                                       │
function add(0, 6) {                                   │
    if(0 == 0) {                                       │
        return 6;───────────────────┘
    } else {
        return add(m-1, n)+1;
    }
};

console.log(    add(4,6)            )
console.log(    add(3,6)+1          )
console.log(   {add(2,6)+1}+1       )
console.log(  {[add(1,6)+1]+1}+1    )
console.log( {[<add(0,6)+1>+1]+1}+1 )
console.log( {[<    6   +1>+1]+1}+1 )
console.log(  {[    7   +1]+1}+1    )
console.log(   {    8   +1}+1       )
console.log(        9   +1          )
console.log(       10               )

ファイル数取得(){
	// TODO
	return ファイル数
}

ファイル数取得(フォルダパス){
	変数（数値）　ファイル数　＝　0
	変数（配列）　ファイルリスト　＝　フォルダパスのファイルをすべて取得
	変数（配列）　フォルダリスト　＝　フォルダパスのフォルダをすべて取得
	
	ファイル数　＋＝　ファイルリストの要素の数
	
	//TODO
	
	return ファイル数
}

ファイル数取得(フォルダパス){
	変数（数値）　ファイル数　＝　0
	変数（配列）　ファイルリスト　＝　フォルダパスのファイルをすべて取得
	変数（配列）　フォルダリスト　＝　フォルダパスのフォルダをすべて取得
	
	ファイル数　＋＝　ファイルリストの要素の数
	
	for(フォルダリストの要素の数分回す){
		変数（文字列）　サブフォルダパス　＝　フォルダリストの要素
		ファイル数　＋＝　ファイル数取得(サブフォルダパス)
	}
	
	return ファイル数
}

ファイル数取得(フォルダパス){
	
	変数（数値）　ファイル数　＝　0
	変数（配列）　未検査フォルダリスト　＝　[]
	
	未検査フォルダリスト　push　フォルダパス
	
	while(未検査フォルダリストが空になるまで) {
		変数（文字列）　検査フォルダパス　pop　未検査フォルダリスト
		変数（配列）　ファイルリスト　＝　検査フォルダパスのファイルをすべて取得
		変数（配列）　フォルダリスト　＝　検査フォルダパスのフォルダをすべて取得
		
		ファイル数　＋＝　ファイルリストの要素の数
		未検査フォルダリスト　push　フォルダリスト
	}
	
	return ファイル数
}

// phina.js をグローバル領域に展開
phina.globalize();

// MainScene クラスを定義
phina.define('MainScene', {
	superClass: 'DisplayScene',

	// 初期処理
	init: function() {

		// 親クラス初期化
		this.superInit({
			// 画面サイズ
			width: 600,
			height: 600,
		});
		// 背景色を指定
		this.backgroundColor = '#EEE';

		// ラベルを生成
		this.label = Label('Hello, phina.js!').addChildTo(this);
		this.label.x = this.gridX.center(); // x 座標
		this.label.y = this.gridY.center(); // y 座標
		this.label.fill = 'black'; // 塗りつぶし色
		
		// グリッド線作成
		(9).times(function(i){
			var path1 = PathShape()
				.addPath(0, 600/8*i)
				.addPath(600, 600/8*i)
				.addChildTo(this);
			var path2 = PathShape()
				.addPath(600/8*i, 0)
				.addPath(600/8*i, 600)
				.addChildTo(this);
		}, this);
		
		// ラベルを生成
		this.kaisou = Label('test').addChildTo(this);
		this.kaisou.setPosition(this.gridX.span(10), this.gridY.span(1));
		this.heya = Label('test').addChildTo(this);
		this.heya.setPosition(this.gridX.span(10), this.gridY.span(2));
		
		// 初期処理部分
		this.hierarchyLevel = 3; // 階層
		this.unitCount = Math.pow(2, this.hierarchyLevel); // 部屋の縦（横）の個数
		this.unitWidth = this.width / this.unitCount; // 部屋の横のサイズ
		this.unitHeight = this.height / this.unitCount; // 部屋の縦のサイズ

		// 衝突オブジェクトリストを作成
		this.colObjList = [];
		this.colObjCount = 0;
		// 四角を複数個作成
		for(; this.colObjCount<31; this.colObjCount++) {
			let rect = RectangleShape().addChildTo(this);
			rect.setPosition(Math.randint(0, 600),Math.randint(0, 600)); // 位置はランダムにする
			rect.setSize(30,30);
			rect.draggable;

			rect.id = this.colObjCount; // ID
			rect.headRoomNo = 0; // 左上の部屋番号（最下層）
			rect.tailRoomNo = 0; // 右下の部屋番号（最下層）
			rect.hierNo = -1; // 階層番号
			rect.roomNo = 0; // 部屋番号
			
			// それぞれの四角にIDを表示
			let label = Label(rect.id).addChildTo(rect);
			label.fill = 'white'; // 塗りつぶし色

			this.colObjList[rect.id] = rect;
		}
		
		// オブジェクトの衝突の木をSetで埋める
		this.colObjBelongTree = new Array(this.hierarchyLevel + 1);
		for (let i=0; i < this.colObjBelongTree.length; i++) {
			this.colObjBelongTree[i] = new Array(Math.pow(4, i));
			for(let j=0; j < this.colObjBelongTree[i].length; j++) {
				this.colObjBelongTree[i][j] = new Set();
			}
		}
		this.colObjBelongTree[-1] = [new Set()];

	},

	// 毎フレーム処理
	update: function(app) {
		// ここに処理を記述
		let colObjList = this.colObjList;
		for(let colObj of colObjList) {
			
			// 旧番号を保持
			let oldHierNo = colObj.hierNo;
			let oldRoomNo = colObj.roomNo;
			
			// 左上の部屋番号を割り出す
			let headRoomX = Math.trunc(colObj.left / this.unitWidth);
			headRoomX = Math.clamp(headRoomX, 0, this.unitCount-1);
			let headRoomY = Math.trunc(colObj.top / this.unitHeight);
			headRoomY = Math.clamp(headRoomY, 0, this.unitCount-1);
			colObj.headRoomNo = this.bitSeparate32(headRoomX) | (this.bitSeparate32(headRoomY)<<1);

			// 右下の部屋番号を割り出す
			let tailRoomX = Math.trunc(colObj.right / this.unitWidth);
			tailRoomX = Math.clamp(tailRoomX, 0, this.unitCount-1);
			let tailRoomY = Math.trunc(colObj.bottom / this.unitHeight);
			tailRoomY = Math.clamp(tailRoomY, 0, this.unitCount-1);
			colObj.tailRoomNo = this.bitSeparate32(tailRoomX) | (this.bitSeparate32(tailRoomY)<<1);
			
			// 全体の階層をもとに自分のオブジェクトがいる階層を割り出す
			let xorRoom = colObj.headRoomNo ^ colObj.tailRoomNo;
			xorRoom = (xorRoom & 0xaaaaaaaa) | (xorRoom << 1 & 0xaaaaaaaa);
			xorRoom |= (xorRoom >>> 1);
			xorRoom |= (xorRoom >>> 2);
			xorRoom |= (xorRoom >>> 4);
			xorRoom |= (xorRoom >>> 8);
			xorRoom |= (xorRoom >>> 16);
			
			xorRoom = (xorRoom & 0x55555555) + ((xorRoom >>> 1) & 0x55555555);
			xorRoom = (xorRoom & 0x33333333) + ((xorRoom >>> 2) & 0x33333333);
			xorRoom = (xorRoom & 0x0f0f0f0f) + ((xorRoom >>> 4) & 0x0f0f0f0f);
			xorRoom = (xorRoom & 0x00ff00ff) + ((xorRoom >>> 8) & 0x00ff00ff);
			xorRoom = (xorRoom & 0x0000ffff) + ((xorRoom >>> 16) & 0x0000ffff);
			
			colObj.hierNo = (this.hierarchyLevel - (xorRoom/2));

			// 部屋番号を割り出す
			colObj.roomNo = colObj.headRoomNo >>> xorRoom;

			// 旧番号と異なる場合は部屋を移し替える
			if (oldHierNo != colObj.hierNo || oldRoomNo != colObj.roomNo) {
				this.colObjBelongTree[oldHierNo][oldRoomNo].delete(colObj.id);
				this.colObjBelongTree[colObj.hierNo][colObj.roomNo].add(colObj.id);
			}
		}
		
		//ここに衝突予想ペアのリストを作成する処理を記述する 
		
		// 階層と部屋を表示
		this.kaisou.text = "階層：" + colObjList[0].hierNo;
		this.heya.text = "部屋：" + colObjList[0].roomNo;

	}, 
	
	bitSeparate32: function(n) {
		n = (n|(n<<8)) & 0x00ff00ff;
		n = (n|(n<<4)) & 0x0f0f0f0f;
		n = (n|(n<<2)) & 0x33333333;
		return (n|(n<<1)) & 0x55555555;
	},
	
	makeCombiList: function(paramList) {
		let result = [];
		for (let i=0; i < paramList.length-1; i++){
			for(let j=i+1; j < paramList.length; j++) {
				result.push([paramList[i], paramList[j]]);
			}
		}
		return result;
	},
	
	makeCrossJoinList: function(list1, list2) {
		let result = [];
		for (let i=0; i < list1.length; i++){
			for(let j=0; j < list2.length; j++) {
				result.push([list1[i], list2[j]]);
			}
		}
		return result;
	},

});


// メイン処理
phina.main(function() {
	// アプリケーション生成
	let app = GameApp({
		startLabel: 'main',
		fit: false,
		query: '#sample01',
		width: 600, //縦のサイズ
		height: 600, //横のサイズ
	});
	// アプリケーション実行
	app.run();
});

ファイル数取得(フォルダパス){
	変数（数値）　ファイル数　＝　0
	変数（配列）　ファイルリスト　＝　フォルダパスのファイルをすべて取得
	変数（配列）　フォルダリスト　＝　フォルダパスのフォルダをすべて取得
	
	ファイル数　＋＝　ファイルリストの要素の数
	
	for(フォルダリストの要素の数分回す){
		変数（文字列）　サブフォルダパス　＝　フォルダリストの要素
		ファイル数　＋＝　ファイル数取得(サブフォルダパス)
	}
	
	return ファイル数
}

let self = this;
function collisionPairPullOut(){
	
	let collisionPairList = [];
	
	
	return collisionPairList;
}

let self = this;
function collisionPairPullOut(hierNo, roomNo){
	
	let collisionPairList = [];
	
	// 自分の部屋のオブジェクトリストを取得
	let objSet = self.colObjBelongTree[hierNo][roomNo];
	objSet.length = objSet.size;
	let objList = Array.from(objSet)
	
	return collisionPairList;
}

let self = this;
function collisionPairPullOut(hierNo, roomNo){
	
	let collisionPairList = [];
	
	// 自分の部屋のオブジェクトリストを取得
	let myObjSet = self.colObjBelongTree[hierNo][roomNo];
	myObjSet.length = myObjSet.size;
	let myObjList = Array.from(myObjSet)
	
	// 祖先と自分の部屋のオブジェクト同士
	// TODO
	
	// 自分の部屋のオブジェクト同士
	let myPairList = self.makeCombiList(myObjList);
	collisionPairList = collisionPairList.concat(myPairList);
	
	// 自分の子孫に対して同じ処理を繰り返す
	// TODO
	
	return collisionPairList;
}

let self = this;
function collisionPairPullOut(hierNo, roomNo){
	
	let collisionPairList = [];
	
	// 自分の部屋のオブジェクトリストを取得
	let myObjSet = self.colObjBelongTree[hierNo][roomNo];
	myObjSet.length = myObjSet.size;
	let myObjList = Array.from(myObjSet)
	
	// 祖先と自分の部屋のオブジェクト同士
	// TODO
	
	// 自分の部屋のオブジェクト同士
	let myPairList = self.makeCombiList(myObjList);
	collisionPairList = collisionPairList.concat(myPairList);
	
	// 自分の子孫に対して同じ処理を繰り返す
	for(let i=0; i<4; i++){
		let childPairList = collisionPairPullOut(hierNo+1, roomNo*4+i);
		collisionPairList = collisionPairList.concat(childPairList);
	}
	
	return collisionPairList;
}

let self = this;
function collisionPairPullOut(hierNo, roomNo){
	
	let collisionPairList = [];
	
	// 自分の部屋のオブジェクトリストを取得
	let myObjSet = self.colObjBelongTree[hierNo][roomNo];
	myObjSet.length = myObjSet.size;
	let myObjList = Array.from(myObjSet)
	
	// 祖先と自分の部屋のオブジェクト同士
	// TODO
	
	// 自分の部屋のオブジェクト同士
	let myPairList = self.makeCombiList(myObjList);
	collisionPairList = collisionPairList.concat(myPairList);
	
	// 自分の子孫に対して同じ処理を繰り返す
	if(hierNo >= self.hierarchyLevel) {return collisionPairList;}
	for(let i=0; i<4; i++){
		let childPairList = collisionPairPullOut(hierNo+1, roomNo*4+i);
		collisionPairList = collisionPairList.concat(childPairList);
	}
	
	return collisionPairList;
}

let self = this;
function collisionPairPullOut(hierNo, roomNo){
	
	let collisionPairList = [];
	
	// 自分の部屋のオブジェクトリストを取得
	let myObjSet = self.colObjBelongTree[hierNo][roomNo];
	myObjSet.length = myObjSet.size;
	let myObjList = Array.from(myObjSet)
	
	// 祖先と自分の部屋のオブジェクト同士
	// TODO
	
	// 自分の部屋のオブジェクト同士
	let myPairList = self.makeCombiList(myObjList);
	collisionPairList = collisionPairList.concat(myPairList);
	
	// 自分の子孫に対して同じ処理を繰り返す
	if(hierNo >= self.hierarchyLevel) {return collisionPairList;}
	for(let i=0; i<4; i++){
		let childPairList = collisionPairPullOut(hierNo+1, roomNo*4+i, myObjList);
		collisionPairList = collisionPairList.concat(childPairList);
	}
	
	return collisionPairList;
}

let self = this;
function collisionPairPullOut(hierNo, roomNo, parentObjList){
	
	let collisionPairList = [];
	
	// 自分の部屋のオブジェクトリストを取得
	let myObjSet = self.colObjBelongTree[hierNo][roomNo];
	myObjSet.length = myObjSet.size;
	let myObjList = Array.from(myObjSet)
	
	// 祖先と自分の部屋のオブジェクト同士
	// TODO
	
	// 自分の部屋のオブジェクト同士
	let myPairList = self.makeCombiList(myObjList);
	collisionPairList = collisionPairList.concat(myPairList);
	
	// 自分の子孫に対して同じ処理を繰り返す
	if(hierNo >= self.hierarchyLevel) {return collisionPairList;}
	for(let i=0; i<4; i++){
		let childPairList = collisionPairPullOut(hierNo+1, roomNo*4+i, myObjList);
		collisionPairList = collisionPairList.concat(childPairList);
	}
	
	return collisionPairList;
}

let self = this;
function collisionPairPullOut(hierNo, roomNo, parentObjList){
	
	let collisionPairList = [];
	
	// 自分の部屋のオブジェクトリストを取得
	let myObjSet = self.colObjBelongTree[hierNo][roomNo];
	myObjSet.length = myObjSet.size;
	let myObjList = Array.from(myObjSet)
	
	// 祖先と自分の部屋のオブジェクト同士
	let myAndParentPairList = self.makeCrossJoinList(parentObjList, myObjList);
	collisionPairList = collisionPairList.concat(myAndParentPairList);
	
	// 自分の部屋のオブジェクト同士
	let myPairList = self.makeCombiList(myObjList);
	collisionPairList = collisionPairList.concat(myPairList);
	
	// 自分の子孫に対して同じ処理を繰り返す
	if(hierNo >= self.hierarchyLevel) {return collisionPairList;}
	for(let i=0; i<4; i++){
		let childPairList = collisionPairPullOut(hierNo+1, roomNo*4+i, myObjList);
		collisionPairList = collisionPairList.concat(childPairList);
	}
	
	return collisionPairList;
}

let self = this;
function collisionPairPullOut(hierNo, roomNo, parentObjList){
	
	let collisionPairList = [];
	
	// 自分の部屋のオブジェクトリストを取得
	let myObjSet = self.colObjBelongTree[hierNo][roomNo];
	myObjSet.length = myObjSet.size;
	let myObjList = Array.from(myObjSet)
	
	// 祖先と自分の部屋のオブジェクト同士
	let myAndParentPairList = self.makeCrossJoinList(parentObjList, myObjList);
	collisionPairList = collisionPairList.concat(myAndParentPairList);
	
	// 自分の部屋のオブジェクト同士
	let myPairList = self.makeCombiList(myObjList);
	collisionPairList = collisionPairList.concat(myPairList);
	
	// 自分の子孫に対して同じ処理を繰り返す
	if(hierNo >= self.hierarchyLevel) {return collisionPairList;}
	let mixObjList = parentObjList.concat(myObjList);
	for(let i=0; i<4; i++){
		let childPairList = collisionPairPullOut(hierNo+1, roomNo*4+i, mixObjList);
		collisionPairList = collisionPairList.concat(childPairList);
	}
	
	return collisionPairList;
}

let self = this;
function collisionPairPullOut(hierNo, roomNo, parentObjList){
	
	中略
	
	return collisionPairList;
}

let collisionPairList = collisionPairPullOut(0, 0, []);