Jump to content

Demonic God

Member
 View Profile  See their activity

  • Posts

    257

  • Joined

  • Last visited

  • Days Won

    12

 Content Type 

Posts posted by Demonic God

  19. Winderwild / Attack Bonus Aura not working

    in Bug Report

    Posted

    As title - the aura does not provide any attack (supposed to be 50%)

    This is reflected on both the stat page and the actual combat damage.

    Tests done:

    Lorerootian archers + 2 Winderwild vs no Winderwild: Same piercing damage (attack based). Boosted percentage damage (power based). Winderwilds lowered defense by 50 (attack based - same as base attack)

    2 Chaos archers + 1 winderwild; 2 Chaos + 1 colored Winderwild: Dealt 40 damage (90 attack from Chaos - 50 defense from Reanimated Roots). Not boosted.

  20. Bringing out the dead

    in Previous Years MD Birthday threads

    Posted · Edited by Demonic God

    So… a Death Anchor
    Per description (thanks Aelis :D) – It is meant to hide the dead, rather, the crawling dead, from the perception of the corpse collector.
    The first thing that I noted, is that Death Anchors are associated with locations. It is a characteristic of a location itself.
    However – According to MaGoHi (Man with Many Lists) and Fang Archbane (The Bird that spent too much time dead), the locations that has Death Anchor, as a characteristic, often changes. This implies:

    • Death Anchor, is something that can be granted to a location
    • Likewise, this property may be lost through time
    • It is something associated with scenes, but not directly a property of the scene itself

    A notable location, as I’m aware of, however, the Gazebo of Equilibrium, seems to consistently possess Death Anchor.
    This anniversary provided us with a fantastic opportunity to study the formation of a Death Anchor – which seems to have formed inside the Indexed Room of Memories.
    Coincidentally, this location was used repeatedly as a quest hosting site – Particularly by Fyrd Argentus. I theorize that these events are connected to the formation of the Death Anchor phenomenon.
    On the other end of things – I’d raise the question of, how does a Death Anchor prevent the collection of corpses?
    It was known, beyond any doubts, that it directly hides the dead from the Corpse Collector. Which, I would theorize these two possibilities:

    • By hiding the presence/body of the corpse.
    • By tampering with the perception of the Corpse Collector

    Connecting these two clues - the formation of a Death Anchor around a recently popular location, and the existence of Anchors around iconic, crowded spots - I assume that the presence of characters provides an environment that give rise to Death Anchors.

    As it would seem that the Anchor persist as long as the location remains popular - regardless of how many people are in it, rather, gathering locations that varied on a daily basis did not form any Anchor at all, consistency seems to be far more important than temporal popularity.

    I'd theorize the three main ingredients needed to mimic such behavior:

    • The essence of a player
    • The element of consistency
    • The element of everlasting

    While it is unclear what is it, of the living, that deceives the Death collector, to err on the safe size - the following ingredients would, in my opinion, most distinctively associate itself with the essence of a player:

    • Erolin heat
    • Vital Energy
    • Personal items

    Erolin heat, as we know, can be provided through heat jars, or players directly. However, it needs to be constantly supplied to function, as such, jars would be used to provide the device with storage capacity.

    Vital energy exists in multiple forms - but hard to be separated. I'd believe, that a living creature, that possess much vitality and regenerative capability, to be best suited. A hollow warrior, or an animated tree, are ideal candidates.

    Personal items, namely autographs, blood drops, and bottled emotions, to be safe, all three types of sufficient quantity and diversity would be needed.

    The latter two elements are a lot more abstract - but I do believe that there are two principle that perfectly apply here:

    • Principle of Cyclicity
    • Principle of Time

    To channel the energies of these two principles - I believe would require the use of a Wishpoint. Wishpoint itself are powerful artifacts - which can be used to activate spelldocs using Principles. This very characteristic would be required to channel the massive amount of Principle needed.

    In summary, the following ingredients will be needed:

    • 24 x 18k Heat Jars, capable of storing 5 days of heat when fused
    • 1 Animated Trees, maxed out, preferably those with colors
    • 7 full sets of Bottled Emotions, Blood drops, Autograph, from 7 unique players
    • 20,000 of Principle of Cyclicity
    • 20,000 of Principle of Time
    • 1 WP
    • 20 Glue, to fuse items together
    • 10 GiveVital spellstone, for self-repair mechanisms
    • 10 Heat Spellstone, for self-repair mechanism
    • 1 Dream Joker, as a sentient being serving as the brain of the construct
    • Axe and saw, for carving

    The process, as follow:

    • Fusing the heatjar together, into one massive jar
    • Carve out the Animated Tree, as the main housing for various mechanics needed - but take care not to injure it
    • Hang the Bottled Emotions, Blood drops, Autographs, around the Tree branches
    • Inscribe the spellstones into the three body
    • Glue the Joker into the Tree, and place the WP in his palm - he can handle it, he was made from a WP
    • Channel the Principle into the WP

    This new, half living, half construct, creation, will hopefully, serve well as a Death Anchor.

  25. The mason's puzzle

    in Previous Years MD Birthday threads

    Posted

    A bit late... o well. I'm not even sure why I made this, since most contestant drew their own thing xD. This is a tool to visualize what you made, and the scores you get... provided that it doesn't throw an error.

    For those that likes tinkering around, this might be fun for you to poke around with :D

    from graphics import *

BORDER_THICKNESS = 3
SQUARE_THICKNESS = 50

SHAPES = {
	'T_SHAPE':{
				frozenset({(0,0,0),(0,1,0),(0,2,0),(0,1,1)}),
				frozenset({(0,0,0),(0,0,1),(0,0,2),(0,1,1)}),
				frozenset({(0,0,1),(0,1,1),(0,2,1),(0,1,0)}),
				frozenset({(0,1,0),(0,1,1),(0,1,2),(0,0,1)})
			},
	'L_SHAPE':{
				frozenset({(0,0,0),(0,1,0),(0,2,0),(0,0,1)}),
				frozenset({(0,0,0),(0,1,0),(0,2,0),(0,2,1)}),
				frozenset({(0,0,0),(0,0,1),(0,0,2),(0,1,0)}),
				frozenset({(0,0,0),(0,0,1),(0,0,2),(0,1,2)}),
				frozenset({(0,0,1),(0,1,1),(0,2,1),(0,0,0)}),
				frozenset({(0,0,1),(0,1,1),(0,2,1),(0,2,0)}),
				frozenset({(0,1,0),(0,1,1),(0,1,2),(0,0,0)}),
				frozenset({(0,1,0),(0,1,1),(0,1,2),(0,0,2)})
			},
	'Z_SHAPE':{
				frozenset({(0,0,0),(0,1,0),(0,1,1),(0,2,1)}),
				frozenset({(0,0,1),(0,1,1),(0,1,0),(0,2,0)}),
				frozenset({(0,0,0),(0,0,1),(0,1,1),(0,1,2)}),
				frozenset({(0,1,0),(0,1,1),(0,0,1),(0,0,2)})
			},
	'I_SHAPE':{
				frozenset({(0,0,0),(0,1,0)}),
				frozenset({(0,0,0),(0,0,1)})
			},
	'DOT_SHAPE':{
				frozenset({(0,0,0)})
			}
}

POINTS = {
	'Z_SHAPE': 4,
	'T_SHAPE': 3,
	'L_SHAPE': 3,
	'I_SHAPE': 1,
	'DOT_SHAPE': 0
}

COLORS = {
	'Z_SHAPE': 'red',
	'T_SHAPE': 'green',
	'L_SHAPE': 'blue',
	'I_SHAPE': 'purple',
	'DOT_SHAPE': 'yellow',
	'BORDER': 'black'
}

def rotateFlat(shape):
	o = []	#re-order
	detect = [max(x) for x in [*zip(*shape)]]
	if detect[0] == 0:
		return shape # already flat
	elif detect[1] == 0:
		o = [1,0,2]
	elif detect[2] == 0:
		o = [2,1,0]
	else:
		raise Exception('Nonrotatable shape')

	return {(x[o[0]],x[o[1]],x[o[2]]) for x in shape}

def getSimplifiedShape(index, matrix):
	tiles = []
	for x,surface in enumerate(matrix):
		for y,line in enumerate(surface):
			for z,point in enumerate(line):
				if point == index:
					tiles.append([x,y,z])

	simplifier = [min(x) for x in [*zip(*tiles)]]	#Transpose to find min x y z
	simplified_shape = {(tile[0] - simplifier[0], tile[1] - simplifier[1], tile[2] - simplifier[2]) for tile in tiles}
	simplified_shape = rotateFlat(simplified_shape)

	return simplified_shape

def getShape(index, matrix):
	simplified_shape = getSimplifiedShape(index, matrix)
	for SHAPE in SHAPES:
		if simplified_shape in SHAPES[SHAPE]:
			return SHAPE
	else:
		print(f'Cannot find shape {simplified_shape}')
		raise Exception()

def getColor(matrix, layer, x, y):
	if isBorder(x,y):
		return COLORS['BORDER']
	elif isInnerBorder(x,y):
		if _isInnerBorder(x) and not _isInnerBorder(y):
			x, y = getIndex(x,y)
			index_1 = matrix[layer][y][x-1]
			index_2 = matrix[layer][y][x]
		elif _isInnerBorder(y) and not _isInnerBorder(x):
			x, y = getIndex(x,y)
			index_1 = matrix[layer][y-1][x]
			index_2 = matrix[layer][y][x]
		else:
			return COLORS['BORDER']

		if index_1 == index_2:
			shape = getShape(index_1, matrix)
			return COLORS[shape]
		else:
			return COLORS['BORDER']
	else:
		x, y = getIndex(x,y)
		index = matrix[layer][y][x]
		shape = getShape(index, matrix)
		return COLORS[shape]

def draw(matrix, offset_x = 30, offset_y = 30):
	size = BORDER_THICKNESS * 9 + SQUARE_THICKNESS * 8
	window = GraphWin(width = size * 3  + offset_x * 4, height = size + offset_y * 2 + 40)

	indexSet = set()
	score = 0
	for surface in matrix:
		for line in surface:
			for index in line:
				if index in indexSet:
					continue
				else:
					indexSet.add(index)
					score += POINTS[getShape(index, matrix)]

	message = Text(Point(window.getWidth() / 2 - 50, window.getHeight() - 40), f'Score: {score}')
	message.setTextColor('black')
	message.setSize(20)
	message.draw(window)

	for layer in range(3):
		for y in range(size):
			x = 0
			while x < size:
				color = getColor(matrix, layer, x, y)
				point_a = Point(x + offset_x * (layer + 1) + layer * size, y + offset_y)

				if color != COLORS['BORDER']:
					if _isInnerBorder(x):
						length = BORDER_THICKNESS
					else:
						length = SQUARE_THICKNESS
				elif _isBorder(y):
					length = size
				elif _isInnerBorder(x) or _isBorder(x):
					length = BORDER_THICKNESS
				else:
					length = SQUARE_THICKNESS

				point_b = Point(point_a.getX() + length	, point_a.getY())
				x += length
				line = Line(point_a, point_b)
				line.setFill(color)
				line.draw(window)


def _isBorder(x):
	return x < BORDER_THICKNESS or x >= ((BORDER_THICKNESS + SQUARE_THICKNESS) * 8)

def isBorder(x, y):
	return _isBorder(x) or _isBorder(y)

def _isInnerBorder(x):
	if _isBorder(x):
		return False

	while x >= BORDER_THICKNESS + SQUARE_THICKNESS:
		x -= BORDER_THICKNESS + SQUARE_THICKNESS
		if _isBorder(x):
			return True

	return False

def isInnerBorder(x,y):
	if isBorder(x,y):
		return False

	return _isInnerBorder(x) or _isInnerBorder(y)

def getIndex(x,y):
	return (x//(BORDER_THICKNESS + SQUARE_THICKNESS), y//(BORDER_THICKNESS + SQUARE_THICKNESS))

testArr = [
			[
				[0, 0, 1, 1, 1, 2, 2, 2],
				[3, 0, 0, 1, 4, 13, 14, 2],
				[3, 17, 18, 4, 4, 21, 22, 23],
				[24, 25, 26, 27, 4, 29, 30, 31],
				[32, 33, 34, 35, 36, 37, 38, 39],
				[40, 41, 42, 43, 44, 45, 46, 47],
				[48, 49, 50, 51, 52, 53, 54, 55],
				[56, 57, 58, 59, 60, 61, 62, 63]
			],
			[
				[64, 65, 66, 67, 68, 69, 70, 71],
				[72, 73, 74, 75, 76, 77, 78, 79],
				[80, 81, 82, 83, 84, 85, 86, 87],
				[88, 89, 90, 91, 92, 93, 94, 95],
				[96, 97, 98, 99, 100, 101, 102, 103],
				[104, 105, 106, 107, 108, 109, 110, 111],
				[112, 113, 114, 115, 116, 117, 118, 119],
				[120, 121, 122, 123, 124, 125, 126, 127]
			],
			[
				[128, 129, 130, 131, 132, 133, 134, 135],
				[136, 137, 138, 139, 140, 141, 142, 143],
				[144, 145, 146, 147, 148, 149, 150, 151],
				[152, 153, 154, 155, 156, 157, 158, 159],
				[160, 161, 162, 163, 164, 165, 166, 167],
				[168, 169, 170, 171, 172, 173, 174, 175],
				[176, 177, 178, 179, 180, 181, 182, 183],
				[184, 185, 186, 187, 188, 189, 190, 191]
			]
		]

# draw(testArr)
f = open("blocks.txt", "r", encoding="utf-8")
matrix = []
layer = []
for line in f:
	line.replace(';',' ').replace(',',' ')
	data = [int(x) for x in line.split()]
	if len(data) == 0:
		continue
	assert len(data) == 8
	layer.append(data)
	if len(layer) == 8:
		matrix.append(layer)
		layer = []

f.close()

draw(matrix)
input("Enter any key to quit.")

    You'd need to have python + graphics.py installed. Make a text file, name it "blocks.txt", and it *should* work.

    Here's an example of how "blocks.txt" should look like :D

    0 0 1 1 1 2 2 2
3 0 0 1 4 13 14 2
3 17 18 4 4 21 22 23
24 25 26 27 4 29 30 31
32 33 34 35 36 37 38 39
40 41 42 43 44 45 46 47
48 49 50 51 52 53 54 55
56 57 58 59 60 61 62 63

64 65 66 67 68 69 70 71
72 73 74 75 76 77 78 79
80 81 82 83 84 85 86 87
88 89 90 91 92 93 94 95
96 97 98 99 100 101 102 103
104 105 106 107 108 109 110 111
112 113 114 115 116 117 118 119
120 121 122 123 124 125 126 127

128 129 130 131 132 133 134 135
136 137 138 139 140 141 142 143
144 145 146 147 148 149 150 151
152 153 154 155 156 157 158 159
160 161 162 163 164 165 166 167
168 169 170 171 172 173 174 175
176 177 178 179 180 181 182 183
184 185 186 187 188 189 190 191

    If you don't get any of this... well, it's just a tool ~~that I made after Yoshi submitted numbers~~ that is kinda used to grade stuff.

    I'll be making the grading script for the rock-paper-scissor game later, for those who wants to poke around with that too :D

×
×
  • Create New...