Whether you know the game or not, this FFG promo video is very well-made and worth watching either way:

Back when I got the original game, I invited some friends over to play it a couple of times, and we had a great time -- but people had problems wrapping their heads around the tech trees, and some would have preferred if I’d have bought the game in German. There’s plenty of cards that come with StarCraft, and having them just sitting there in a pile won’t help understanding which ones help which troops.

Furthermore, the expansion did add (of course) new cards, and even new faction-specific card types, so things didn’t get any easier. Having to mentally translate stuff all the time doesn’t help with forming strategies. So, here’s my newest little player aid:

A four-page spreadsheet that lists and translates to German all event cards, racial techs, leadership cards, abilities and modules (currently version 1.1).

I hope it helps my German-speaking, StarCraft-playing readers, all three of them

This is what came out of it: Yet Another Doom Math Sheet, v. 1.1

It is, basically, a little statistical breakdown of a few values (average, median, minimum, maximum) for a couple variables (range, damage) for each of a marine’s weapons and each invader’s demon. It might help players decide to punch a Trite over trying to shoot it with the pistol, from close range – or at least, that is my hope.

It also goes to show how different some medians are from their respective averages, which is the interesting part.

Tell me if you find it useful, or if you’d change something

Version history

• 08-12-17: v1.0 – Initial release
• 08-12-18: v1.1 – Added columns for non-miss averages and medians, explanations in a row below the values, and a copyright notice

But, phenomenologists have a point: There are things science just can’t explain (yet?), and often, when trying to incorporate science (or rather, the scientific methods) and the way we have subjective intentionality, philosophers of mind either didn’t bring forth an entirely convincing argument or invented terms like supervenience or epiphenomenalism that essentially say “we don’t know how exactly, but it just happens”.

That didn’t satisfy me. So I went to write a paper of my own about the subject:

The Legitimation of Traditional Phenomenology in a Rational-Causalist World

From the Abstract:

Traditional phenomenology has both gained new followers and new opponents in the last years. Followers, because it can explain things other approaches (like neurophysiology, or even psychology) can’t. Opponents, because it is dualist in nature and not really compatible with the way our science these days operates.

I will, in this short paper, attempt to show up how the good and important findings of traditional phenomenology can be incorporated in our rational-causalist world view, while at the same time avoiding to commit to its controversial parts. I will also show why I choose this approach and not one starting with traditional phenomenology.

To that end, I will attempt to single out two fundamental dogmas of phenomenology – that mental objects are immaterial, and that mental objects are (or can be) directed at physical entities – and show in what way altering those changes the entire theory that’s built upon them, enabling a reading of phenomenology that takes its contents serious and at the same time is compatible with a rational-causalist world view.

I did hand in the paper already, and I’m really looking forward to discussing it with the Professor later this month.

Keep in mind that I’m still merely a student working on his Diploma thesis (equivalent to Master under Bologna), so I’m sure I still have lots to learn Particularly the whole subjectivity issue isn’t quite solved yet.

Also, thanks to Prof. Marbach for this opportunity and an always open ear, Ste for the feedback during the writing of this paper, and to my wife Arzo for her awesome support.

Update 08-11-13, 15:52: Gee, I just had the first part (originally meant to be the whole) of some kind of a review discussion with Prof. Marbach, and I realized I misunderstood quite a few things about phenomenology, while I was not entirely clear on quite a few points in the paper, too, and actually have some things in there that border being factual errors. It’s great that I see those now, the idea that I could was one of the main things that drove me when writing the paper and putting forth such a controversial point. But take this as a word of caution – even less than I thought in this work here can be taken at face value, and I’ll revise quite a few points for my diploma thesis.

If however you’re interested in Twilight Imperium, this little 2:19 movie that shows an entire game of it might be of interest for you (music probably not everybody’s favourite, I love this track though). I did play all three races, and consequently made many mistakes, bear with me

The whole thing took about 250 photographs (and three camera battery reloads) to make, they’re shown at a rate of roughly one picture every half second.

Game Report

So what happens, actually? (Keep in mind that if you haven’t heard of the Twilight Imperium rules before, this might not clear up that much…)

There’s three parties; the Embers of Muaat (a lava dwelling species that starts out quite strong with a War Sun in play already) in red, the Winnu (kinda tech-diplomats, they like to scheme) with purple, and the Emirates of Hacan (focused mostly on trade) with yellow ships.

Note that due to the setup, the Winnu were kinda cut off from the center, while Hacan and Muaat were split by quite some empty space, and obstacles prevented access to Mecatol Rex (the planet in the middle) from two sides, left and right in the video, and kinda split the entire map apart. There’s also just one wormhole, which ends up being the only way to the Wormhole Nexus with its planet Mallice.

In the beginning, all three attempted to grab as many planets as possible, fighting hostile locals and greeting friendly ones -- nothing unexpected until around 0:30 the Muaat went for Mecatol Rex in turn 3 (they had tried successfully to boost their War Sun to a movement of 2 for that, in fact). The tension between the Muaat on Mecatol Rex and the Hacan base next to it (the locals had given them a free base there) kept rising afterwards.

Everybody kept building up until, shortly after 1:00, the Hacan made their move for Mecatol Rex -- their private objective required them to control it. The Muaat proved to be fierce defenders though and only one Ground Force and a single Carrier survived (and they were lucky to get Mecatol Rex, too), so the Winnu, who also needed Mecatol Rex for their private objective, decided to make a dash through the empty space and get some foothold amidst the two other parties.

Another arms race ensued, until at 1:25 the Muaat went for Mecatol Rex again -- they didn’t actually need it, but wanted to keep everybody focused on the central planet. Their private objective was to have 6 planets with tech specializations -- the Muaat had 3 in their own territory, the Winnu had 2 border planets with that and the Hacan had one, all of them with little or no defense. The distraction proved successful (I actually forgot about those border planets later on, with the Hacan in particular)…

1:35 brought a big twist for the trade-centered Hacan, one that the movie doesn’t properly show: Class Struggle came into play, despite them doing everything in their might against it; a law that spreads the wealth from trade evenly, basically destroying one of their biggest advantages.

Around 1:40 another Winnu fleet makes its way slowly towards the center. The Winnu were, at that point, focusing on tech: They wanted Advanced Fighters, to make those little cheap ships into real pests; some action cards helped them (they used Alien Technology, Corporate Sponsorship and Focused Research, all in one round) and they got there -- but not without sacrificing many valuable resources and precious time.

The Hacan had already passed for that round, when the Muaat made their dash for the private objective, between 1:45 and 1:50: The Winnu‘s border world fell first, and thanks to the Warfare II High Alert token the Hacan world was easy prey as well. Despite the Winnu voiding the Muaat‘s control over Hope’s End with its Artifact through Local Unrest (and thus denying them one victory point), the Muaat still were leading on the victory point track.

The next round then brought the decision -- the Muaat went for the Bureaucracy strategy, hoping for a quick stolen win through Imperium Rex (at a chance of 40%, not bad odds -- but admittedly, I knew it was coming, not sure if that influenced my Muaat‘s will to go and see if it was there).

The Hacan allied with the Winnu, seeing Muaat too powerful, and made another go for Mecatol Rex -- successfully at that, a huge step closer to fulfilling their private objective. The Winnu tried to force the Muaat back, too (but left them one planet); they couldn’t wait and build up any longer because otherwise, the Muaat would have run into their backyard with their fast War Sun.

At 2:05, it’s all over, when the Muaat uncover the Imperium Rex public objective and win the game, at 6 victory points.

Dim primitiveVector As clsVector
Set primitiveVector = New clsVector
Dim myInt As Integer
myInt = 3
 
primitiveVector.AddItem myInt

There are of course other people who have made such a thing, and there’s the VBA Collection, but none of them quite fit what I wanted. I wanted a Vector that had random access, was able to handle LIFO and FIFO (and thus act as stack and queue), addition and insertion and deletion, could check for item existence, and had dynamic resizing. So I went and coded my own. I did this while working at Promino AG and thus the code is technically theirs, so thanks to Paul Moser for the nod for publishing this under the GNU Lesser General Public License.

You can download both classes (two? more below), together with a tiny trivial testing framework, as Access 2002-2003 .mdb.

This here is the vector class for Variants. It goes into a new class module, I called mine “clsVector”:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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

Option Compare Database
Option Explicit
 
' Copyright 2007, 2008 by Promino AG
' Author: Guido Gloor
'
' This program is free software: you can redistribute it and/or modify
' it under the terms of the GNU Lesser General Public License as published by
' the Free Software Foundation, either version 3 of the License, or
' (at your option) any later version.
'
' This program is distributed in the hope that it will be useful,
' but WITHOUT ANY WARRANTY; without even the implied warranty of
' MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
' GNU Lesser General Public License for more details.
'
' You should have received a copy of the GNU Lesser General Public License
' along with this program.  If not, see <http://www.gnu.org/licenses/>.

Private itemCount As Integer
Private itemBufferSize As Integer
Private itemBuffer() As Variant
 
Private Sub Class_Initialize()
    itemCount = 0
    itemBufferSize = 100
    NewDimensions
End Sub
 
Private Sub NewDimensions()
    ReDim Preserve itemBuffer(itemBufferSize) As Variant
End Sub
 
Private Sub CheckDimensions()
    If itemCount > itemBufferSize - 2 Then
        itemBufferSize = itemBufferSize * 2
        NewDimensions
    End If
End Sub
 
Public Sub ShrinkDimensions()
    itemCount = itemBufferSize + 10
    NewDimensions
End Sub
 
Public Function GetSize() As Integer
    GetSize = itemCount
End Function
 
Public Sub AddItem(item As Variant)
    CheckDimensions
    itemBuffer(itemCount) = item
    itemCount = itemCount + 1
End Sub
 
Public Function GetItem(index As Integer) As Variant
    GetItem = itemBuffer(index)
End Function
 
Public Function PopItem() As Variant
    PopItem = itemBuffer(itemCount - 1)
    DeleteItem itemCount - 1
End Function
 
Public Function GetNextQueueItem() As Variant
    GetNextQueueItem = itemBuffer(0)
    DeleteItem 0
End Function
 
Public Function ContainsItem(item As Variant) As Boolean
    Dim i As Integer
    ContainsItem = False
 
    For i = 0 To itemCount - 1
        If itemBuffer(i) = item Then ContainsItem = True
    Next i
End Function
 
Public Sub InsertItem(index As Integer, item As Variant)
    Dim i As Integer
 
    CheckDimensions
    For i = itemCount - 1 To index Step -1
        itemBuffer(i + 1) = itemBuffer(i)
    Next i
    itemBuffer(index) = item
    itemCount = itemCount + 1
End Sub
 
Public Sub DeleteItem(index As Integer)
    Dim i As Integer
 
    For i = index + 1 To itemCount - 1
        itemBuffer(i - 1) = itemBuffer(i)
    Next i
    itemCount = itemCount - 1
End Sub
 
Public Function IsEmpty() As Boolean
    IsEmpty = itemCount <= 0
End Function

Now, it would be nice if we would be done. But, we’re not done yet, obviously, after all there’s plenty more code below this break. The reason for that is simple: In VBA, a Variant is not an Object, and an Object is not a Variant, consequently functions that take Objects don’t take Variants and vice versa (although you can technically store an Object in a Variant, this will lead to problems). Objects also happen to have “Set” mandatory in places where it isn’t allowed for Variants.

What this means is that there is no way to have the same Vector class for both your custom ADTs and the primitive data types. So basically, we have another class that has exactly the same functions and exactly the same algorithms, but takes Objects instead of Variants. I called mine “clsObjectVector”. Here is the source for the class module:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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

Option Compare Database
Option Explicit
 
' Copyright 2007, 2008 by Promino AG
' Author: Guido Gloor
'
' This program is free software: you can redistribute it and/or modify
' it under the terms of the GNU Lesser General Public License as published by
' the Free Software Foundation, either version 3 of the License, or
' (at your option) any later version.
'
' This program is distributed in the hope that it will be useful,
' but WITHOUT ANY WARRANTY; without even the implied warranty of
' MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
' GNU Lesser General Public License for more details.
'
' You should have received a copy of the GNU Lesser General Public License
' along with this program.  If not, see <http://www.gnu.org/licenses/>.

Private itemCount As Integer
Private itemBufferSize As Integer
Private itemBuffer() As Object
 
Private Sub Class_Initialize()
    itemCount = 0
    itemBufferSize = 100
    NewDimensions
End Sub
 
Private Sub NewDimensions()
    ReDim Preserve itemBuffer(itemBufferSize) As Object
End Sub
 
Private Sub CheckDimensions()
    If itemCount > itemBufferSize - 2 Then
        itemBufferSize = itemBufferSize * 2
        NewDimensions
    End If
End Sub
 
Public Sub ShrinkDimensions()
    itemCount = itemBufferSize + 10
    NewDimensions
End Sub
 
Public Function GetSize() As Integer
    GetSize = itemCount
End Function
 
Public Sub AddItem(item As Object)
    CheckDimensions
    Set itemBuffer(itemCount) = item
    itemCount = itemCount + 1
End Sub
 
Public Function GetItem(index As Integer) As Object
    Set GetItem = itemBuffer(index)
End Function
 
Public Function PopItem() As Object
    Set PopItem = itemBuffer(itemCount - 1)
    DeleteItem itemCount - 1
End Function
 
Public Function GetNextQueueItem() As Object
    Set GetNextQueueItem = itemBuffer(0)
    DeleteItem 0
End Function
 
Public Function ContainsItem(item As Object) As Boolean
    ' The used ADTs need to have an Equals function for this to work
    Dim i As Integer
    ContainsItem = False
 
    For i = 0 To itemCount - 1
        If itemBuffer(i).Equals(item) Then ContainsItem = True
    Next i
End Function
 
Public Sub InsertItem(index As Integer, item As Object)
    Dim i As Integer
 
    CheckDimensions
    For i = itemCount - 1 To index Step -1
        Set itemBuffer(i + 1) = itemBuffer(i)
    Next i
    Set itemBuffer(index) = item
    itemCount = itemCount + 1
End Sub
 
Public Sub DeleteItem(index As Integer)
    Dim i As Integer
 
    For i = index + 1 To itemCount - 1
        Set itemBuffer(i - 1) = itemBuffer(i)
    Next i
    itemCount = itemCount - 1
End Sub
 
Public Function IsEmpty() As Boolean
    IsEmpty = itemCount <= 0
End Function

This is it, have fun As much as you can have if you’re forced to work with VBA, that is.

Oh, and if you can use it – comments are appreciated

The Chinese Room

When I started preparing for my upcoming diploma thesis about consciousness, the possibility of AI and how it all fits together, I couldn’t help but stop at this thought experiment that the famous and bright philosopher John Searle brought up in 1980.

Few papers are still so disputed after now 25 years (although, this being philosophy we’re talking about, all papers are still somewhat disputed after hundreds of years), and the subject matter is as or more current as it was then: The Chinese Room, brought up in the article Minds, Brains and Programs that was published in the journal Behavioural and Brain Sciences.

In short, the thought experiment that my paper (link further down) tries to shed a light on, goes as follows, synopsis mine and maybe a tad jovial for the subject:

There is a thinking homunculus in a room who doesn’t understand Chinese, but has an elaborate set of rules gouverning his actions.

He receives pieces of paper from scientists on the outside, with Chinese symbols, processes them with his rules and paints other Chinese symbols that he returns to the outside – without understanding a thing.

Now the scientists outside cackle with glee, for they think they have crafted a machine that, by merely following rules, can understand Chinese.

However, so Searle argues, since the homunculus on the inside doesn’t understand Chinese, the whole machine can’t possibly understand Chinese (as there is no single part that does the understanding). From this and the similarity from this to any other machine, he follows that no machine can possibly have true understanding and as such, strong AI (that he defines as truly understanding) cannot exist.

OK, so … is he right? Is (strong) AI research doomed?

There are of course several answers to this, quite different in both approach and consequences:

• Yes, he’s right. Now, that would be boring, and if I’d believe this I wouldn’t have written this blog post nor the paper it’s about.
• We don’t even want strong AI research, what Searle deems “weak AI” is actually a huge feat and more than enough for all our wishes. Which Searle doesn’t deny by the way, he didn’t mean to diminish the value of “weak AI” by calling it “weak” (which I can’t help but find a tiny bit funny) and respects advances.
• Searle seems to underestimate the complexity of the required rules, and believes that we can wrap our heads around a machine with millions of moving parts consisting of pipes and flows of water. While I do think that we can’t due to too limited mental capacity, I do believe that Searle is aware of that restriction of ours and, as he makes clear himself, believes in a matter of principle that doesn’t change with growing system complexity.
• His argument is fundamentally flawed and looking for the smallest atomic bit of understanding (or, as he later specifies, the non-reproducible biological-causal properties of the human brain that a computer can’t have by matter of principle and material) is the wrong approach in the first place. Searle basically dismisses this because he finds it ridiculous and contradictory to common sense.

Myself, I like to put myself into the last of those camps. Particularly because I don’t believe in such a thing as “common sense” being actually common, or even a guideline towards truth.

For all those approaches trying to disprove him, Searle thinks he showed they’re wrong – and with most of his rebuttals, I’ll have to admit that I agree with him wholeheartedly. However, there are a few points where I strongly disagree despite all due respect for one of the greatest thinkers of our time.

And those points are where my paper regarding that subject comes into play:

The Chinese Chatroom

I try and figure out which arguments can be found in which ones of the various answers that said article provoked already upon the time of its release (and in particular those that were printed in the same issue of the journal), research what the Turing Test and (even more so) the Turing Machine are really about, and how the question and possibility of simulation versus replication of causal effects come into play.

I’m quite convinced that if what the current perception of the Turing Machine as “a machine to replicate all machines” is correct (which I know hasn’t been mathematically proven), there is no such thing as a fundamental problem with us eventually getting to the point where we do or at least can have strong AI, with machines that are very similar in functionality (albeit probably necessarily much more powerful) to today’s computers.

I’ll have to add that since I wrote this paper, I read quite a bit more about some subjects that appear in the paper, and meanwhile I could add more references to philosophers (in particular, Daniel Dennett) who share views similar to mine and have developed them a lot further than I could so far.

Intro

Tech by Unit

So I bought Twilight Imperium 3rd Edition last week nearly two weeks ago (gee…), and got to play some … well, solitaire test games with 1v1 players that pretended not to know each other’s hands. The game shines more with every added player I’m told, but one is a bit few either way.

With a little game coming up somewhat soon with a couple of friends (you know who you are), I was going through the available resources to help them get into the not that easy rules, and have already collected tons of links, some of which are more or less the essentials:

• A nice graphical Order of Play Overview, very nice for at-a-glance knowledge of “what comes next now?”
• A wonderful Tech Tree, with some more rules (that we won’t need for the first game) on the 2nd page
• A Rules Cheatsheet, although I found this less useful for actual in-game reference

Tech by Unit Player Aid

What I didn’t find however was a way to find out which units have what techs available. So I went ahead and created a little piece of reference paper of my own:

The Tech by Unit Player Aid, currently version 1.3

Also see the FFG discussion thread, and it’s available on BoardGameGeek, too. So what it includes is:

• A short description with strategic and tactical pointers for each unit, to help complete newbies understand the purpose of the units
• Coordinates for Nephilim’s Tech Tree (the same as above), as without the actual tree it’s not that easy finding out what tech you have to research for obtaining which unit-specific upgrades
• The number of prerequisite tech researches for the shortest path (starting from nothing) to each tech, to make it easier to see which ones are obtainable earlier and which later

I hope this helps some people, old and new players alike

Version History

• 08-08-25 v1.0 Initial Release
• 08-08-25 v1.1 Some typos fixed, unit descriptions expanded
• 08-08-27 v1.2 Further typos fixed, added some cost efficiency ratings, added one tech to GF
• 08-09-07 v1.3 Added limits per unit, and copyright notice