objects/experimental/walker-2.cfg

{
id: "walker-2",
is_human: true,

#
#consts list:
#axels - [[x,y], …, [x,y]] A list of spots to anchor legs to. Function returns corrected for rotation.
#
#
#vars list:
#axRot - list of rotations for the legs attached to axels.
#!overshoot - average of how much we need to 'overshoot' by to get to our desired rotation
#legs - list of legs, two per axel. ~≘ axels.
#rotvel - an integer specifying speed of rotation.
#
#
#functions list:
#spnTmpDbg(self, coordinate pair) - Makes a one frame long target image.
#spnDbg(self, coordinate pair) - Spawn a little target image.
#getAxels(self) - Where self.id = walker-2, return consts.axels corrected
#					for displacement and rotation.
#getUpperLegLoc(self) - Returns a list containing two xy pairs for each axel.~≘ axels [[[x,y],[x,y]], …, [[x,y],[x,y]]]
#getUpperLegRot(self) - Returns a list containing two rotations for each axel. ≘ legs. [[rot, rot], …, [rot,rot]]
#setUpperLegs(self, locs, rots) - Sets the upper leg objects attached to self. Takes self,
#									locs (as from getUpperLegLoc), and rots (as from getUpperLegRot).
#getKneeLoc(self) - Returns a list containing rotations for each leg. Structurally ≘ legs.
#getLowerLegLoc(self) - List containing two xy pairs for each lower leg. ≘ getUpperLegLoc.
#getLowerLegRot(self) - As above, but returns rotations.
#setLowerLegs(self, locs, rots) - Like setUpperLegs, but for the lower legs.
#getFeet(self) - Returns a list containing each foot with a structure ≘ legs.
#					This as in, getFeet . axel
# . back(0th)leg? = data element.
#getFeetLoc(self, level) Returns a location pair for each foot, based on joint rotation.
#getFeetTouch(self, level) Tells which feet are touching. 0 for not, 1 for is.
#newStepPos(self, level) Returns the coordinate pair of each foot's current footprint. [-1, -1] indicates foot in air.
#getRealFootLoc(self, level) Returns the location of the foot as defined by the leg rots, or
#								as defined by it's last footprint.
#getFootBodyDist(self, level) Distance between axel and foot for each leg.
#getUpperLegLen(self) Length of the first upper leg segment.
#getLowerLegLen(self) Of the lower leg segment. Integer.
#getLLRealRot(self, level) See getLowerLegRot. This one is corrected for collision.
#getLLRealLoc(self, level) See getLowerLegLoc. Collision.
#
functions: "def spnTmpDbg (self, crd) [
			spawn('walker-2.dbg', crd[0], crd[1], self.facing, [die()] )
		];

		def spnDbg (self, crd) [
			spawn('walker-2.dbg', crd[0], crd[1], self.facing)
		];

		def getAxels (self)
			map(range(size(axels)), 'axel_num',
				#At this point, 'axel' is an x,y pair.#
				map(range(2), 'n', rot_axel[n]+midpoint[n])
				where rot_axel = orbit_obj(0, 0,
					 						angle(0, 0, axel[0], axel[1]) + rotate,
											length(0, 0, axel[0], axel[1]))
				where axel = axels[axel_num])
			where axels = self.consts.axels
			where midpoint = [self.midpoint_x, self.midpoint_y]
			where rotate = self.rotate;

		def getUpperLegRot (self)
			map(range(size(axels)), 'axel_num',
				map(range(size(axels[axel_num])), 'crd_num',
					#Here, leg is the upper leg object.#
					leg.vars.bjRot+rotate
					where leg = legs[axel_num][crd_num]
				)
			)
			where axels = getAxels(self)
			where legs = self.vars.legs
			where rotate = self.rotate;

		def getUpperLegLoc (self)
			map(range(size(axels)), 'axel_num',
				map(range(size(axels[axel_num])), 'crd_num',
					#Here, leg is the upper leg object.#
					orbit_obj(
						axels[axel_num][0],
						axels[axel_num][1],
						90 + angle[axel_num][crd_num] + legs.vars.bjRot,
						length(0,0,leg.consts.bjLoc[0],leg.consts.bjLoc[1])
					)
					where leg = legs[axel_num][crd_num]
				)
			)
			where axels = getAxels(self)
			where legs = self.vars.legs
			where angle = getUpperLegRot(self);

		def getKneeLoc (self)
			map(range(size(axels)), 'axel_num',
				map(range(size(axels[axel_num])), 'crd_num',
					orbit_obj(
						axels[axel_num][0],
						axels[axel_num][1],
						90 + angle[axel_num][crd_num] + legs.vars.bjRot,
						length(leg.consts.ljLoc[0],leg.consts.ljLoc[1],leg.consts.bjLoc[0],leg.consts.bjLoc[1])
					)
					where leg = legs[axel_num][crd_num]
				)
			)
			where axels = getAxels(self)
			where legs = self.vars.legs
			where angle = getUpperLegRot(self);

		def setUpperLegs (self, locs, rots)
			map(range(size(locs)), 'varA',
				map(range(size(locs[varA])), 'varB',
					[
						set(legcp.midpoint_x, locs[varA][varB][0]),
						set(legcp.midpoint_y, locs[varA][varB][1]),
						set(legcp.rotate, rotate),
					] where legcp = legs[varA][varB]
					where rotate = rots[varA][varB]
				)
			)
			where legs = self.vars.legs;

		def getLowerLegLoc (self)
			map(range(size(knees)), 'knee_num',
				map(range(size(knees[knee_num])), 'knee_sub',
					orbit_obj(
					knee[0],
					knee[1],
					90 + pRot + leg.vars.ljRot,
					length(0,0,leg.vars.leg.consts.joint[0],leg.vars.leg.consts.joint[1])
					)
					where knee = knees[knee_num][knee_sub] #coord#
					where leg = legs[knee_num][knee_sub] #object#
					where pRot = gulr[knee_num][knee_sub]
				)
			)
			where legs = self.vars.legs
			where knees = getKneeLoc(self)
			where gulr = getUpperLegRot(self);

		def getLowerLegRot (self)
			map(range(size(axels)), 'axel_num',
				map(range(size(axels[axel_num])), 'crd_num',
					#Here, leg is the upper leg object.#
					leg.vars.bjRot+leg.vars.ljRot+rotate
					where leg = legs[axel_num][crd_num]
				)
			)
			where axels = getAxels(self)
			where legs = self.vars.legs
			where rotate = self.rotate;

		def setLowerLegs (self, locs, rots)
			map(range(size(locs)), 'varA',
				map(range(size(locs[varA])), 'varB',
					[
						set(legcp.midpoint_x, locs[varA][varB][0]),
						set(legcp.midpoint_y, locs[varA][varB][1]),
						set(legcp.rotate, rotate),
					] where legcp = legs[varA][varB].vars.leg
					where rotate = rots[varA][varB].vars.leg
				)
			)
			where legs = self.vars.legs;

		def getFeetLoc (self)
			map(range(size(knees)), 'knee_num',
				map(range(size(knees[knee_num])), 'knee_sub',
					orbit_obj(
					knee[0],
					knee[1],
					90 + pRot + leg.vars.ljRot,
					length(0,0,leg.vars.leg.consts.joint[0]-leg.vars.leg.consts.foot[0],
							leg.vars.leg.consts.joint[1]-leg.vars.leg.consts.foot[1])
					)
					where knee = knees[knee_num][knee_sub] #coord#
					where leg = legs[knee_num][knee_sub] #object#
					where pRot = gulr[knee_num][knee_sub]
				)
			)
			where legs = self.vars.legs
			where knees = getKneeLoc(self)
			where gulr = getUpperLegRot(self);

		def getFeetTouch (self, level)
			map(range(size(feet)), 'axel',
				map(range(size(feet[axel])), 'foot',
					solid(level, feet[axel][foot][0], feet[axel][foot][1], 2, 2)
				)
			)
			where feet = getFeetLoc(self);

		def newStepPos (self, level)
			map(range(size(feet)), 'axel',
				map(range(size(feet[axel])), 'foot',
					if(fs = 0,
						if(sl != [-1,-1], [-1,-1], sl),
						if(sl = [-1,-1], fl, sl)
					)
					where fl = feet[axel][foot]
					where fs = tState[axel][foot]
					where sl = stepLoc[axel][foot]
				)
			)
			where feet = getFeetLoc(self)
			where tState = getFeetTouch(self, level)
			where stepLoc = self.vars.stepLoc;

		def getRealFootLoc (self, level)
			map(range(size(prints)), 'axel',
				map(range(size(prints[axel])), 'foot',
					if(prints[axel][foot] = [-1, -1],
						rotFeet[axel][foot],
						prints[axel][foot]
					)
				)
			)
			where rotFeet = getFeetLoc(self)
			where prints = newStepPos(self, level)
		;

		def getFootBodyDist (self, level) #side b#
			map(range(size(axels)), 'axel',
				map(range(size(axels[axel])), 'leg',
					length(axels[axel][0], axels[axel][1], feet[axel][leg][0], feet[axel][leg][1])
				)
			)
			where axels = getAxels(self)
			where feet = getRealFootLoc(self, level)
		;

		def getUpperLegLen (self) #side a#
			abs(self.vars.legs[0][0].consts.bjLoc[1])+abs(self.vars.legs[0][0].consts.ljLoc[1])
		;

		def getLowerLegLen (self) #side c#
			abs(self.vars.legs[0][0].vars.leg.consts.joint[1])+abs(self.vars.legs[0][0].vars.leg.consts.foot[1])
		;

		def getLLRealRot (self, level)
			map(range(size(bs)), 'axel',
				map(range(size(bs[axel])), 'leg',
					-angle_alpha(a,b,c)		#needs proper bend direction checking.#
					where b = bs[axel][leg]
				)
			)
			where a = getUpperLegLen(self)
			where c = getLowerLegLen(self)
			where bs = getFootBodyDist(self, level)
		;

		def getLLRealLoc (self, level)
			map(range(size(rots)), 'axel',
				map(range(size(rots)), 'leg',
					orbit_obj(fprt[0], fprt[1], rot, len)
					where rot = rots[axel][leg]-90
					where len = length(legs[axel][leg].vars.leg.consts.foot[0], legs[axel][leg].vars.leg.consts.foot[1], 0, 0)
					where fprt = ftLoc[axel][leg]
				)
			)
			where legs = self.vars.legs
			where rots = getLLRealRot(self, level)
			where ftLoc = getRealFootLoc(self, level)
		;

		def getRealKnee (self, level)
			map(range(size(rots)), 'axel',
				map(range(size(rots)), 'leg',
					orbit_obj(fprt[0], fprt[1], rot, len)
					where rot = rots[axel][leg]-90
					where fprt = ftLoc[axel][leg]
				)
			)
			where len = getLowerLegLen(self)
			where legs = self.vars.legs
			where rots = getLLRealRot(self, level)
			where ftLoc = getRealFootLoc(self, level)
		;

#broken	def getULRealRot (self, level)
			map(range(size(knees)), 'axel',
				map(range(size(knees)), 'leg',
					angle(0, 0, knees[axel][leg][0]-axels[axel][0], knees[axel][leg][1]-axels[axel][1])
				)
			)
			where axels = getAxels(self)
			where knees = getRealKnee(self, level)
		;
#
		def getULRealRot (self, level)
			map(range(size(bs)), 'axel',
				map(range(size(bs[axel])), 'leg',
					angle_theta(a,b,c)		#needs proper bend direction checking.#
					where b = bs[axel][leg]
				)
			)
			where a = getUpperLegLen(self)
			where c = getLowerLegLen(self)
			where bs = getFootBodyDist(self, level)
		;

		def getULRealLoc (self, level)
			map(range(size(rots)), 'axel',
				map(range(size(rots)), 'leg',
					orbit_obj(axels[axel][0], axels[axel][1],
						rots[axel][leg]+90,
						length(legs[axel][leg].consts.bjLoc[0],
							legs[axel][leg].consts.bjLoc[1], 0, 0))
				)
			)
			where axels = getAxels(self)
			where rots = getULRealRot(self, level)
			where legs = self.vars.legs
		;",
vars: {
	axRot: [],
	overshoot: 0,
	legs: [[]],
	rotvel: 0,
},
consts: {
	axels: [[-28,4],[56,4]],
},
on_create: "[
		map(range(size(self.consts.axels)), 'avar',
			map(range(2), 'bvar',
				spawn('walker-2.upper-leg', x, y, self.facing, set_var('listAddress', [avar,bvar])))),
		set(vars.legs, map(range(size(consts.axels)), ['-','+'])),
		set(vars.stepLoc, map(range(size(consts.axels)), [[-1,-1], [-1,-1]])),
		set(vars.axState, map(range(size(consts.axels)), ['ok','ok'])), #ok, nopres, lgone, ugone#
	]",
on_done_create: "set(self.vars.legs,
			map(range(size(self.consts.axels)), 'index',
				map(range(size(self.consts.axels[index])), 'subIndex',
					self.tmp.legs[context.index*2+subIndex])))",
on_ctrl_right: "[
		map(getRealKnee(self, level), 'crd', spnDbg(self, crd[0])),
		debug(getULRealRot(self, level)),
	]",
on_ctrl_left: "map(range(size(knees)), 'axel',
				map(range(size(knees)), 'leg',
					[spawn('walker-2.dbg', axels[axel][0], axels[axel][1], self.facing),
					spawn('walker-2.dbg', knees[axel][leg][0], knees[axel][leg][1], self.facing),
					#debug(angle(axels[axel][0], axels[axel][1], knees[axel][leg][0], knees[axel][leg][1])),#
					#OK, what the heck is going on here - angle is returning the wrong data, and it bloody well shouldn't be.#
					debug(axels[axel][0], axels[axel][1], knees[axel][leg][0], knees[axel][leg][1])
					]
				)
			)
			where axels = getAxels(self)
			where knees = getRealKnee(self, level)",
on_process: "[
		#debug(getFootBodyDist(self, level)),#
		set(self.vars.stepLoc, nsp),
		setUpperLegs(self, recUpLegPos, getULRealRot(self, level)),
		setLowerLegs(self, recLowLegPos, getLLRealRot(self, level)),
		if(ctrl_down, set(y, y+2)),
		if(ctrl_up, set(y, y-2)),
	]
	where recUpLegPos = getULRealLoc(self, level)
	where recLowLegPos = getLLRealLoc(self, level)
	where nsp = newStepPos(self, level)",
on_end_anim: "animation('normal')",
animation: {
	id: "normal",
	image: "experimental/spiderbot.png",
	rect: [11,9,108,52],
	pad: 0,
	frames: 1,
	duration: 1000,
	item_area: "all",
},
object_type: [
	{
		id: "upper-leg",
		vars: {
			bjRot: 45,
			ljRot: -65,
		},
		consts: {
			bjLoc: [-2,28],
			ljLoc: [-2,-36],
		},

		#vars list:
		#bjRot - big joint rotation, in degrees
		#ljRot - little joint ^
		#listAddress - A unique pair giving this object's index in it's parent's vars.legs list.
		#leg - the spawned leg segment, the lower leg
		#
		#consts list:
		#bjLoc - big joint location with respect to midpoint. Coordinate pair.
		#ljLoc - little joint ^
		on_spawned: "[
			#debug('Spawning leg ' + str(self.vars.listAddress)),#
			set(spawner.tmp.legs, spawner.tmp.legs + [self]),
			if(self.vars.listAddress[1] = 0, set(z, z-5), set(z, z+5)),
			spawn('walker-2.lower-leg', x, y, facing),
		]",
		animation: {
			id: "normal",
			image: "experimental/spiderbot.png",
			rect: [10,64,21,105],
			pad: 0,
			frames: 1,
			duration: 1000,
			item_area: "all",
		},
	},
	{
		id: "lower-leg",
		consts: {
			joint: [-2,-54],
			foot: [0,60],
		},

		#consts list:
		#joint - Coordinate pair for the knee joint, with respect to the foot's midpoint.
		#foot - Coordinate pair indicating the offset of the foot end from the midpoint of the object.
		on_end_anim: "animation('normal')",
		on_spawned: "[set(spawner.vars.leg, child),
		set(z, spawner.z + if(spawner.z<0, 1, -1))]",
		animation: {
			id: "normal",
			image: "experimental/spiderbot.png",
			rect: [34,64,41,122],
			pad: 0,
			frames: 1,
			duration: 1000,
			item_area: "all",
		},
	},
	{
		id: "dbg",
		z: 150,
		on_end_anim: "animation('normal')",
		on_create: "set(z, 150)",
		animation: {
			id: "normal",
			image: "experimental/spiderbot.png",
			rect: [87,65,94,72],
			pad: 0,
			frames: 2,
			duration: 5,
			item_area: "all",
		},
	},
],
}