ProAdvanced/util/util-js/action/jump-0.2.js

/**
 * 跳判断相关脚本代码
 */

function Event() {
	this.events = {};
}
Event.prototype.addEventListener = function(type, listener) {
	this.events[type] = this.events[type] || [];
	this.events[type].push(listener);
};
Event.prototype.trigger = function() {
	for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
	}

	var type = args[0];
	var params = args.slice(1);
	if (!!this.events[type]) {
		// console.log("type:",type);
		this.events[type].forEach(function(listener) {
			try {
				listener.apply(null, params);
			} catch (e) {
				console.error(e);
			}
		});
	}
};
var jumpOpts = {
	//是否上升的标志位
	isDirectionUp: false,
	//持续上升次数
	continueUpCount: 0,
	//上一点的持续上升的次数，为了记录波峰的上升次数
	continueUpFormerCount: 0,

	continueDownCount: 0,
	continueDownFormerCount: 0,

	//上一点的状态，上升还是下降
	lastStatus: false,
	//波峰值
	peakOfWave: 0,
	//波谷值
	valleyOfWave: 0,
	//检测到极快的波动的次数
	timeOfPeakCount: 0,
	//开始添加
	bUpdateTimeOfPeakCount: false,
	//开始更新的次数
	startCount: 0,
	//停止跳
	bStopJump: false,
	//上次传感器的值
	gravityOld: 0,

	bUpState: false,

	//开始时间
	startTime: 0,
	endTime: 0
}
var ActionJump = function ActionJump() {

	this.jumpOpts = jumpOpts;
	//其他波峰波谷参数相关数组记录
	this.peakOfWaveArray = [];
	this.peakOfWaveMaxValue = 0;
	this.valleyOfWaveArray = [];
	this.valleyOfWaveMinValue = 0;

	this.peakOfWaveArrayValue = [];
	this.valleyOfWaveArrayValue = [];

	this.peakOfWaveArrayValueLinear = [];
	this.valleyOfWaveArrayValueLinear = [];


	this.highestCount = 0;
	//陀螺仪
	this.oriGyroYArray = [];

	this.isJumpTop = false;

	this.event = new Event();


	this.frameCapacity = 6;
	this.frame = [];
	this.frameLength = 5;
	this.frameOffset = 0;

	this.frameHitCapacity = 11;
	this.frameHit = []; //打击后的n帧

	for (var i = 0; i < this.frameCapacity; ++i) {
		var o = new Object();
		// o.acc = [0, 0, 0];
		// o.gyr = [0, 0, 0];
		o.maxValue = 0;
		o.gyroValue = 0;
		o.resultant = 0;
		this.frame.push(o);
	}


}
ActionJump.prototype.addEventListener = function(type, listener) {
	this.event.addEventListener(type, listener);
};


ActionJump.prototype.updateJump = function() {
	let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	//使用三个轴的数据，计算重力轴的加速度。最后减去重力的加速度值
	//********加速计********
	let {
		lAccX,
		lAccY,
		lAccZ
	} = data.linearAcc;
	let {
		oAccX,
		oAccY,
		oAccZ
	} = data.oriAcc;
	let {
		oGyroX,
		oGyroY,
		oGyroZ
	} = data.oriGyro;
	let {
		bYAxis
	} = data;
	let _tempAxisData = bYAxis ? oGyroY : oGyroX;
	this.detectorNewStep(data.resultant, lAccX, lAccY, lAccZ, oAccX, oAccY, oAccZ, data.runIndex, _tempAxisData);
};



/*
 * 检测步子，并开始计步
 * 1.传入数据
 * 2.如果检测到了波峰，并且符合时间差以及阈值的条件，则判定为1步
 * 3.符合时间差条件，波峰波谷差值大于initialValue，则将该差值纳入阈值的计算中
 * */
ActionJump.prototype.detectorNewStep = function(resultant, linearX, linearY, linearZ, oriX, oriY, oriZ, _runIndex,
	_oGyroY) {
	let _judgmentValue = oriZ;
	//判断resultant 一个阀值
	let limitResultant = 20;
	if (!this.jumpOpts.bStopJump) {
		if (resultant > limitResultant && !this.jumpOpts.bUpState) {
			// console.log("开始判断时候:" + resultant);
			this.jumpOpts.bUpState = true;
			this.isJumpTop = false;
			this.highestCount = 0;
			//陀螺仪部分
			this.oriGyroYArray = [];
			this.peakOfWaveArrayValue = [];
			this.valleyOfWaveArrayValue = [];
			this.peakOfWaveArrayValueLinear = [];
			this.valleyOfWaveArrayValueLinear = [];
			this.jumpOpts.startCount = 0;
			//开始更新。加入时间判断
			this.jumpOpts.startTime = new Date().getTime();
			this.event.trigger('resultant', {
				type: "log",
				logType:'normal',
				data: "开始时间:"+this.jumpOpts.startTime
			});
		}
		if (this.jumpOpts.bUpState) {
			let newFrame = this.frame[(this.frameOffset + this.frameLength) % this.frameCapacity];
			
			if (_judgmentValue > 2) {
				newFrame.maxValue = _judgmentValue;
				if (_judgmentValue > this.peakOfWaveMaxValue)
					this.peakOfWaveMaxValue += _judgmentValue;
			} else if (_judgmentValue < -2) {
				newFrame.maxValue = _judgmentValue;
				if (_judgmentValue < this.valleyOfWaveMinValue)
					this.valleyOfWaveMinValue += _judgmentValue;
			}
			if (Math.abs(_oGyroY) > 5){
				this.oriGyroYArray.push(_oGyroY);
				newFrame.gyroValue = _oGyroY;
			}
			newFrame.resultant = resultant;
				
			let currTime = new Date().getTime(); //当前时间
			let diffTime = currTime - this.jumpOpts.startTime; //当前时间减最初时间，得到当前时间差
			// if (diffTime > 200){
			// 	this.jumpOpts.bUpState = false;
			// 	this.event.trigger('resultant', {
			// 		type: "log",
			// 		logType:'normal',
			// 		data: "超时:"+diffTime
			// 	});
			// 	return;
			// };
			//出现极值后
			// Math.abs(linearZ) < 7 &&
			if (Math.abs(resultant) < 7) {
				this.event.trigger('resultant', {
					type: "log",
					logType:'normal',
					data: '出现极值后：'+ resultant+",时间:"+diffTime
				});
				// if (diffTime < 150){
					// this.jumpOpts.bUpState = false;
					// return;
				// };
				// this.event.trigger('resultant', {
				// 	type: "log",
				// 	logType:'normal',
				// 	data: "************触发成功************"
				// });
				
				this.highestCount++;
				if (this.highestCount >= 1) {
					//达到最高点，
					this.jumpOpts.bStopJump = true;
					this.jumpOpts.bUpdateTimeOfPeakCount = true;

					let _currentMaxValue = 0;

					if (Math.abs(this.peakOfWaveMaxValue) > Math.abs(this.valleyOfWaveMinValue)) {
						_currentMaxValue = this.peakOfWaveMaxValue;
					} else {
						_currentMaxValue = this.valleyOfWaveMinValue;
					}

					let allOGyroValue = 0;
					for (let i = 0; i < this.oriGyroYArray.length; i++) {
						allOGyroValue += this.oriGyroYArray[i];
					}
					allOGyroValue /= this.oriGyroYArray.length;
					
					let _frameMaxValue = 0,_frameGyroValue = 0;
					for (let i = 0; i < this.frame.length; i++) {
						_frameMaxValue += this.frame[i].maxValue;
						_frameGyroValue += this.frame[i].gyroValue;
					}
					console.log("frame:"+_frameMaxValue + " == "+ _frameGyroValue);

					//后面通用使用这个类型传输数据
					this.event.trigger('resultant', {
						type: "stateDataOfJump",
						currentMaxValue: _frameMaxValue,
						peakOfWaveMaxValue: this.peakOfWaveMaxValue,
						valleyOfWaveMinValue: this.valleyOfWaveMinValue,
						oGyroValue: _frameGyroValue/this.frame.length,
						resultant: resultant,
						name: "highestCountEnd"
					});
					// this.jumpOpts.bUpState = false;
					
					
					// this.jumpOpts.bStopJump = false;
					this.event.trigger('resultant', {
						type: "stop"
					});
					this.resetAll();
				}
			}
			if ((this.frameOffset += 1) >= this.frameCapacity) {
				this.frameOffset -= this.frameCapacity;
			}
		}
	}else if (this.jumpOpts.bUpdateTimeOfPeakCount ) {
		// console.log("结束判断时候:" + resultant);
		this.jumpOpts.timeOfPeakCount++;
		//todo 如果直跳，可以调节更小的 limitTimeOfPeakCount 30
		let limitTimeOfPeakCount = 10;
		if (this.jumpOpts.timeOfPeakCount >= limitTimeOfPeakCount) {
			this.jumpOpts.timeOfPeakCount = 0;
			this.jumpOpts.bStopJump = false;
			this.jumpOpts.bUpState = false;
			// this.event.trigger('resultant', {
			// 	type: "stop"
			// });
			// this.resetAll();
			this.jumpOpts.bUpdateTimeOfPeakCount = false;
			// console.log("timeOfPeakCount >= " + limitTimeOfPeakCount);
		}
	}
}

ActionJump.prototype.setBUpState = function(value){
	this.jumpOpts.bUpState = value;
}


//重置对应的参数
ActionJump.prototype.resetAll = function() {
	// console.log('******************* resetAll ******************');
	this.peakOfWaveArray = [];
	this.peakOfWaveMaxValue = 0;
	this.valleyOfWaveArray = [];
	this.valleyOfWaveMinValue = 0;
	this.highestCount = 0;


	this.jumpOpts.continueDownFormerCount = 0;
	this.jumpOpts.continueDownCount = 0;
	this.jumpOpts.continueUpFormerCount = 0;
	this.jumpOpts.continueUpCount = 0;
}

if (typeof module === "object" && typeof module.exports === "object") {
	module.exports = ActionJump;
}