You will need:

• WSL2 setup with Firefox installed (mine uses Ubuntu 20.04)
• VcXsrv
• geckodriver

How it works

VcXsrv starts up an X server on the Windows host machine, and what WSL will do is connect to this server to pass on the details of what programs need to be displayed (in this case, the browser window). Geckodriver is there purely as a middle layer for Selenium to be able to interact with Firefox.

VcXsrv setup

This setups the X server so that Windows can display graphical data coming from the Ubuntu instance.

1. Download and install
2. Start it up with the the command line parameter “-ac”. This flag removes access control restrictions for connecting clients (which is okay as long as this server isn’t exposed on the open Internet and that the only client connecting is the Ubuntu instance)
3. Allow connections to VcXsrv on Windows Firewall

The “-ac” flag and allowing the program through Windows Firewall is pretty important. When I didn’t do this, Ubuntu would give me cryptic error messages like “Broadway display type not supported”, but once I set up these access controls, everything was fine.

Bash setup

Install firefox

sudo apt install firefox

Export DISPLAY variable in .bashrc (or for whatever terminal you use, maybe .zshrc, etc.)

export DISPLAY=$(ip route | awk '{print $3; exit}'):0

This will configure your DISPLAY variable to use the IP address listed in the resolv.conf file. The IP address listed there is the IP address of the X server that will be used for displaying the browser window.

Start up VcXsrv as described in the above and then try to open Firefox. The Firefox window should open.

Geckodriver setup

This acts purely as the API interface that allows Selenium to interact with Firefox. Selenium looks for this executable when controlling the web browser.

1. Download geckodriver (make sure to get the Linux one and not the Windows one)
2. Put it in /usr/bin (or alternatively some other folder in your PATH)

Selenium sample on Python

I tend to use Python when running Selenium code, and I haven’t tried it on another language (I imagine the principles are similar). Here is a piece of sample code for starting up the browser and opening up a website, but really any Selenium code can be used.

import time

from selenium import webdriver
from selenium.webdriver import DesiredCapabilities

def execute_with_retry(method, max_attempts):
    e = None
    for i in range(0, max_attempts):
        try:
            return method()
        except Exception as e:
            print(e)
            time.sleep(1)
    if e is not None:
        raise e

capabilities = DesiredCapabilities.FIREFOX
capabilities["marionette"] = True
firefox_bin = "/usr/bin/firefox"
browser = execute_with_retry(lambda: webdriver.Firefox(
    firefox_binary=firefox_bin, capabilities=capabilities), 10)

browser.get("https://www.google.com")

time.sleep(10)

browser.close()

1. Install Docker on your machine
2. Get a Docker image for a CS 1.6 server (I created this one, which is based off of an existing one. Mine has:
   • A lot of maps
   • Metamod
   • AMXModX (with high ping kicker, podbot control menu, round money, rock the vote, and admin all in one)
   • Podbot
3. Customise the server (e.g. editing the server.cfg, amxx.cfg, and other config files, etc.)
4. Start it up! (the README.md in the above linked Git repos has more info on this)

As far as ports go, I only needed to forward 27015 on my machine, but your mileage may vary. Others have reported that some more ports must also be forwarded on some machines.

Then optionally, if you’re running Ubuntu and you want this server to start up like a service via systemd, you’ll need this:

1. An executable script with path /usr/local/bin/hlds with contents (make sure the DIR variable matches your installation directory):

#!/bin/sh

# Do not change this path
PATH=/bin:/usr/bin:/sbin:/usr/sbin:/usr/local/bin

# The path to the game you want to host. example = /home/newuser/dod
DIR=/opt/cs-16-server/bin
DAEMON=./server

start()
{
    echo  -n "Starting HLDS"
    if [ -e $DIR ]; then
        cd $DIR
        $DAEMON start
    else
        echo "No such directory: $DIR!"
    fi
}

stop()
{
    echo -n "Stopping HLDS"
    if [ -e $DIR ]; then
        cd $DIR
        $DAEMON stop
    else
        echo "No such directory: $DIR!"
    fi
}

reload()
{
    echo -n "Restarting HLDS"
    stop
    sleep 1
    start
}

case "$1" in
    start|stop|reload)
        "$1"
        ;;
    *)
        echo  "Usage: $ 0 {start | stop | reload | status}"
        exit  1
        ;;
esac

exit  0

2. A script with path /etc/systemd/system/hlds.service with contents:

[Unit]
Description=HLDS

[Service]
Type=oneshot
ExecStart=/usr/local/bin/hlds start
ExecStop=/usr/local/bin/hlds stop
ExecReload=/usr/local/bin/hlds reload
RemainAfterExit=yes

[Install]
WantedBy=multi-user.target

3. Then execute:

systemctl daemon-reload
systemctl enable hlds
service hlds start

Feel free to check out my server that’s running right now with the same Docker image! Here’s the command to connect via the console.

connect henrypoon.com:27015

UPDATE 7. JULY 2015: Since this post, my version of LINE has been updated to 4.0.3.367, and it looks like stickers work now!

UPDATE 31. JULY 2016: Looks like in July 2015, LINE released a Chrome app.  Users of Chrome can just use that extension instead of using this method: Link

Running LINE in Ubuntu 14.04

1. Install Wine

sudo apt-get install wine

2. Install VC++ 2008 Redistributable

winetricks vcrun2008

3. Download and install LINE for Windows

Without installing the VC++ 2008 Redistributable, LINE would intermittently crash (even though it was able to start correctly).  This worked on my Ubuntu 14.04 x64 system.

LINE Version: 3.9.1.188
Wine Version: 1.6.2

This post from askubuntu.com hits this issue right on the head: http://askubuntu.com/questions/333534/installing-epson-wf-3520

I thought I’d leave a post here, just so I know where to find it again in case I forget.

In a computer, there are various methods of storing information.  Information can be stored in the processor cache, RAM, hard disk, etc.  It can be faster to request information from a storage medium that is smaller.  However, this smaller storage medium cannot fit all the possible information that can be requested.  So the idea is to insert a portion of the data into the faster, smaller medium (the cache) and the rest into the slower, larger medium (main memory).

If a request is made and the data is not available in the faster, smaller medium first, then the data will be read from the slower, larger medium – this is what is known as a cache miss.

Given that all the data cannot possibly live in the cache, there must be a way to minimize the amount of times that the data must be read from the main memory.

Optimal Caching – Farthest-in-Future

The Algorithm

The idea is that there is an algorithm that minimizes the amount of cache misses that occur for a set of requests.  The Farthest-in-Future Algorithm evicts the item in the cache that is not requested until the farthest in the future.  For example, given the following cache with items “a” through “f”.

It is clear that “g” does not exist in the set of cache items and so when “g” is requested, a cache miss will result. An item will be evicted because “g” is not in the cache.  According to the Farthest-in-Future Algorithm, element “f” will be evicted since it is the one that will be used furthest in the future.

Definitions

Cache Miss – Occurs when it is necessary to bring in an item from the main memory into the cache

Schedule – A list that contains, for each, request, which item is brought into the cache, and which item is evicted

Reduced Schedule – a schedule that only brings in an item when there is a request for that item – so a non-reduced schedule would bring an item into the cache outside of a request for that item

Theorem

To be shown:

Farthest-in-Future is the optimal algorithm that minimizes the number of cache misses.

To prove this, let’s say there is a schedule SFF that follows the Farthest-in-Future Algorithm and that there is a schedule optimal S that has a minimum number of cache misses. It can be shown that it is possible to transform S into SFF by performing a series of evictions without increasing the number of cache misses.  Since S^* is already optimal, and the number of cache misses did not increase, then SFF must be optimal.

To perform one transformation, the statement below can be used.  Right now, it isn’t all that clear why this is necessary, but it should become clearer further on.

Let S be a reduced schedule that is the same as SFF for the first j requests, then there is a reduced schedule S’ that is the same as SFF for the first j+1 requests, and incurs no more misses than S

Proof

Let’s say the cache at the start looks like this.  S and SFF have the exact same contents (this is what was defined in the previous section).

Given a schedule S, it can be shown that any request can be made, and the resulting schedule would be equal to the ideal algorithm and does not increase the number of cache misses.  Essentially, we want S = S’ = SFF after a request is made and that the number of cache misses have not increased.  If this can be shown for all different scenarios that items are requested, then Farthest-in-Future is the ideal algorithm.

Case 1: Item Is Already in the Cache

Now let’s say the next item to be requested is item “d”.  It is clear that this item exists in both caches and no evictions are necessary.  Since no evictions are necessary, SFF does not change.  It was specified in a prior section that there is a schedule S’ that equals SFF, which incurs no more misses than S.

Here, S = S’ because no changes had to be made to the cache and there were no cache misses.  After the request for item “d”, S = S’, each with zero cache misses, which is a valid outcome.

Case 2: Item Is Not in the Cache, S and SFF Evict the Same Item

Let’s say the next item to be requested is item “e”.  Neither cache has this item, so an eviction will have to be made.  Let’s also say SFF and S both choose to evict item “a” to make room for “e”.  It was specified in a prior section that there is a schedule S’ that equals SFF, which incurs no more misses than S.

Here S = S’ because S and SFF both evicted the same item.  Both S and S’ each have one cache miss (no increase relative to one another), which is a valid outcome.

Case 3: Item Is Not in the Cache, S and SFF Each Evict A Different Item

This is where the proof can become more confusing (as if it isn’t already).  Let’s say the next item to be requested is “e”.  Let’s also say that the ideal algorithm, SFF, evicts “a” and S evicts “b”. It was specified in a prior section that there is a schedule S’ that equals SFF, which incurs no more misses than S. This means that in order to get S’ = SFF, S’ should evict “a” in order to match with SFF.

Here, S does not agree with S’ = SFF.  Essentially, these two schedules behave the same, so long as future requests do not request items “a” or “b”.  This shows that there is a schedule S’ that equals SFF, but it is not known whether or not S’ has no more cache misses than S, since “a” or “b” can be requested in the future, which can determine whether S or S’ has more cache misses.  From this point onward, S and S’ behave the same until one of the following happens:

Case 3a: Item Is in SFF, But Not S; S Evicts “a”

Let’s say eventually item “b” gets requested.  In this case, S’ and SFF do not need to change.  All S has to do is evict “a” to make room for “b”.  In this case, S has two total cache misses (from request “e” and “b”), while SFF and S’ each have only one cache miss, thus fulfilling the cache miss requirement.

Case 3b: Item Is Neither in SFF Nor S

Let’s say eventually item “f” gets requested.  S’, SFF, and S all need to make an eviction. S’ and SFF can evict “b” to make room for “f”, and S can evict “a” to make room for “f”.  In this case, each schedule as two cache misses, thus fulfilling the cache miss requirement.

Case 3c: Item Is in SFF, But Not S; S Evicts Item Not Equal to “a”

Let’s say eventually item “b” gets requested and S evicts an item that isn’t “a”, say “c”.  Now, SFF and S’ both already have “b” in the cache.  In order to synchronize S and S’ to make them comparable to see how many cache misses each have, S’ and SFF will evict “c” to make room for “a”.

Since “a” is being brought into the cache without a request for “a”, this makes S’ and SFF no longer a reduced schedule.  However, the proof calls for S’ and SFF being a reduced schedule.  Fortunately, it is possible to transform an unreduced schedule into a reduced one.  In this case, each schedule has two cache misses, thus fulfilling the cache miss requirement.

Case 3d: Item Is Not in SFF, But in S

The only item that is in S and not SFF is item “a”.  SFF had evicted it initially at the beginning of Case 3.  Since SFF had evicted it, it must have been the item that would be requested furthest into the future.  Therefore, it is not possible for item “a” to be requested before other items.

After going through all possible eviction decisions that the schedules can do, it was shown that for each scenario, there was indeed a schedule S’ = SFF, where the cache misses incurred in S’ no more than S.

Switching the Language for Windows

To do this, go to the Control Panel and open the Regional and Language Options.  This might be hard to do when Windows is in a different language so just look for the icon that has a globe on it.  Depending on the version of Windows, switching the language may not be possible.  And also, different versions of Windows put these buttons in different places within the Language Options.  Click around the tabs, and there should be a drop down box for you to change the language.  Once that’s done, restart the computer.

Switching the Language for Office

Hopefully switching the language for Windows worked, because it would really help for this part, although it isn’t necessary.  Not every version of Office supports changing languages.  It depends on the version that was installed.  Go to the Start Menu, find Microsoft Office, and then Microsoft Office Tools.  Under there, there should be an icon for Language Settings.  The icon has a globe and an A on it under Windows 7.  Open it and change the language.

For some reason, even after forwarding these, Direct IP Connection still doesn’t work.

Culprit: Port 2302 (TCP/UDP)

Forward that then it will work.

Computer Specs:

Intel Core 2 Duo T5250 Processor
2 GB RAM @ 667 Ghz
Intel GM965 Chipset
nVidia GeForce 8600M GT
Dell Wireless 1390 802.11g

Installation

I was lucky enough to only need the Retail Snow Leopard Disc (10A432) and the myHack Installer 1.0.1.  I pretty much followed METHOD 2 in this guide (method 1 didn’t really work out for me, but it might have had something to do with the disc restoration part of the guide):

http://prasys.co.cc/2009/08/installing-snow-leopard-for-osx86/

For the myHack installer, check the box for the kext that says something about PS2 in it.  It will enable the laptop touchpad and keyboard.  Also, read the description for each kext to see if you need it or not.

When I used method 1 in the guide, I had some trouble with an installation error that said “Could not verify BaseSystem.pkg” or something along those lines.  That error appeared at about 10-15% installation progress.  It went away then I used method 2.  I did read somewhere that it may have had to do with the restoration in Disk Utility.  Either way, it worked the second time around.

Once SL was installed, I ran the myHack Installer on my drive to get the Chameleon Bootloader on there so I wouldn’t have to use my USB to boot all the time.  Also, be sure not to install GraphicsEnabler as it will prevent your computer from shutting down completely (more on that later).

Graphics

Since my laptop uses an nVidia card, there is an issue that prevents the computer from shutting down completely if the “GraphicsEnabler” option is used in the myHack Installer.  I believe NVInject, NVKush, and NVDarwin all suffer from this same problem.  What happens is that when the shut down command is invoked, the computer’s screen will turn off, the HD will turn off, but the power stays on.  When the nVidia graphics kexts aren’t used, this problem goes away.

I’ve tried generating an EFI String and loading that with EFI Studio, but it didn’t do the job.  The resolution is still 1024×768 and I have no QE, CI or OpenGL support.  What I did later on was install PC EFI to see if that would fix things (I didn’t really know what I was doing here at this point).  That didn’t really work, but I did later find out that EFI Studio allows me to add boot flags.  I added “Graphics Mode”=”1280x800x32” to the boot flag so now it boots with the proper resolution.  It gives the proper resolution, but still no QE/CI or OpenGL.  This guide has information on how to test for QE (Quartz Extreme) and CI (Core Image): http://prasys.co.cc/tag/enable-qeci/

Another thing I tried was to modify my DSDT to get my graphics card working using this link: http://tonymacx86.blogspot.com/2010/01/advanced-dsdt-fixes-nvidia-graphics.html.  I managed to get the card recognized using the DSDT code, but when I got rid of the graphics kexts, and the boot.plist options as specified in the guide, I lost my graphics acceleration.  I know my DSDT code is working here still since System Profiler tells me what card I have with the exact same names that I gave in the DSDT.  It seems that having graphics acceleration and shutdown/restart working properly just isn’t meant to be.

The tradeoff:

I either could have proper graphics acceleration and no shutdown, OR I could have shut down and no graphics acceleration.  Graphics is the clear winner here, but I still hate having no shutdown.  I have not found a fix for this.

Power Management

There was a problem with high CPU temperatures with the laptop.  I installed the VoodooPowerMini kext located here (http://forum.voodooprojects.org/index.php/topic,1095.0.html)

Audio

After looking for various kexts, I found that VoodooHDA worked for me.  It can be found here (http://www.kexts.com/view/70-voodoohda_(32–_64-bit,_recompiled_by_prasys).html).

Wireless

Works after installation.

USB Ports

They work since it can recognize my mouse and USB drive.

Battery Indicator

I used the VoodooBattery kext located here (http://forum.voodooprojects.org/index.php/topic,1092.0.html)

Card Reader

I don’t use this so I didn’t install the kext for it.  It can be found here: http://www.dailyblogged.com/retail-snow-leopard-installation-guide/ or SD Card Fix (more direct).

Touchpad

I had an issue where I couldn’t tap the touchpad in order for it to “click”.  I fixed this issue by installing the VoodooPS2Controller kext (check the Trackpad option during the installation) (http://forum.voodooprojects.org/index.php/topic,235.0.html).  Then I installed the preference pane (this allows configuring the Trackpad through System Prefs) here http://www.dailyblogged.com/retail-snow-leopard-installation-guide/ (command -f to find it).  I opened System Preferences and pressed the Show All button, and I saw a “Trackpad” option, so I opened it and the option was there.

Webcam

Works after installation.

Conclusion

Everything I listed here works except for video and the card reader.  There are other things like Ethernet, but I don’t really use it.

Here is an article that teaches you how to install Snow Leopard in VMWare using a Windows host.

http://www.ihackintosh.com/2009/12/install-snow-leopard-in-vmware-7-windows-edition/

http://www.online-tech-tips.com/mac-os-x/install-snow-leopard-on-pc/

Note:  the darwin_snow.iso must always be mounted in the VM’s CD/DVD drive in order for the OS to boot.   Shutting down the VM by pressing shut down in the OS will cause a kernel panic.  The around it is to open the .vmx file associated with the virtual machine and change smc.present from true to false.

http://www.blogsdna.com/5067/instantly-link-windows-live-id-with-windows-7-user-account.htm